dbdriver.h

Go to the documentation of this file.

 
/***********************************************************************
 Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
 (c) 2004-2009 by Educational Technology Resources, Inc.  Others may
 also hold copyrights on code in this file.  See the CREDITS.txt file
 in the top directory of the distribution for details.
 
 This file is part of MySQL++.
 
 MySQL++ is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published
 by the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.
 
 MySQL++ is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with MySQL++; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
 USA
***********************************************************************/
 
#if !defined(MYSQLPP_DBDRIVER_H)
#define MYSQLPP_DBDRIVER_H
 
#include "common.h"
 
#include "options.h"
 
#include <typeinfo>
 
#include <limits.h>
 
namespace mysqlpp {
 
 
class MYSQLPP_EXPORT DBDriver
{
public:
        enum nr_code {
                nr_more_results,        
                nr_last_result,         
                nr_error,                       
                nr_not_supported        
        };
 
        DBDriver();
 
        DBDriver(const DBDriver& other);
 
        virtual ~DBDriver();
 
        ulonglong affected_rows()
        {
                error_message_.clear();
                return mysql_affected_rows(&mysql_);
        }
 
        std::string client_version() const
        {
                error_message_.clear();
                return mysql_get_client_info();
        }
 
        bool connect(const MYSQL& mysql);
 
        virtual bool connect(const char* host, const char* socket_name,
                        unsigned int port, const char* db, const char* user,
                        const char* password);
 
        bool connected() const { return is_connected_; }
 
        void copy(const DBDriver& other);
 
        bool create_db(const char* db) const;
 
        void data_seek(MYSQL_RES* res, ulonglong offset) const
        {
                error_message_.clear();
                mysql_data_seek(res, offset);
        }
 
        void disconnect();
 
        bool drop_db(const std::string& db) const;
 
        bool enable_ssl(const char* key = 0, const char* cert = 0,
                        const char* ca = 0, const char* capath = 0,
                        const char* cipher = 0);
 
        const char* error()
        {
                return error_message_.length() ? error_message_.c_str() : mysql_error(&mysql_);
        }
 
        int errnum() { return mysql_errno(&mysql_); }
 
        size_t escape_string(char* to, const char* from, size_t length)
        {
                error_message_.clear();
                return mysql_real_escape_string(&mysql_, to, from, 
                                static_cast<unsigned long>(length));
        }
 
        size_t escape_string(std::string* ps, const char* original,
                        size_t length);
 
        static size_t escape_string_no_conn(char* to, const char* from,
                        size_t length)
        {
                return mysql_escape_string(to, from,
                                static_cast<unsigned long>(length));
        }
 
        static size_t escape_string_no_conn(std::string* ps, 
                        const char* original = 0, size_t length = 0);
 
        bool execute(const char* qstr, size_t length)
        {
                error_message_.clear();
                return !mysql_real_query(&mysql_, qstr,
                                static_cast<unsigned long>(length));
        }
 
        MYSQL_ROW fetch_row(MYSQL_RES* res) const
        {
                error_message_.clear();
                return mysql_fetch_row(res);
        }
 
        const unsigned long* fetch_lengths(MYSQL_RES* res) const
        {
                error_message_.clear();
                return mysql_fetch_lengths(res);
        }
 
        MYSQL_FIELD* fetch_field(MYSQL_RES* res, size_t i = UINT_MAX) const
        {
                error_message_.clear();
                return i == UINT_MAX ? mysql_fetch_field(res) :
                                mysql_fetch_field_direct(res,
                                static_cast<unsigned int>(i));
        }
 
        void field_seek(MYSQL_RES* res, size_t field) const
        {
                error_message_.clear();
                mysql_field_seek(res, MYSQL_FIELD_OFFSET(field));
        }
 
        void free_result(MYSQL_RES* res) const
        {
                error_message_.clear();
                mysql_free_result(res);
        }
 
        st_mysql_options get_options() const { return mysql_.options; }
 
        std::string ipc_info()
        {
                error_message_.clear();
                return mysql_get_host_info(&mysql_);
        }
 
        ulonglong insert_id()
        {
                error_message_.clear();
                return mysql_insert_id(&mysql_);
        }
 
        bool kill(unsigned long tid)
        {
                error_message_.clear();
                return !mysql_kill(&mysql_, tid);
        }
 
        bool more_results()
        {
                error_message_.clear();
                #if MYSQL_VERSION_ID > 41000            // only in MySQL v4.1 +
                        return mysql_more_results(&mysql_);
                #else
                        return false;
                #endif
        }
 
        nr_code next_result()
        {
                error_message_.clear();
                #if MYSQL_VERSION_ID > 41000            // only in MySQL v4.1 +
                        switch (mysql_next_result(&mysql_)) {
                                case 0:  return nr_more_results;
                                case -1: return nr_last_result;
                                default: return nr_error;
                        }
                #else
                        return nr_not_supported;
                #endif
        }
 
        int num_fields(MYSQL_RES* res) const
        {
                error_message_.clear();
                return mysql_num_fields(res);
        }
 
        ulonglong num_rows(MYSQL_RES* res) const
        {
                error_message_.clear();
                return mysql_num_rows(res);
        }
 
        bool ping()
        {
                error_message_.clear();
                return !mysql_ping(&mysql_);
        }
 
        int protocol_version()
        {
                error_message_.clear();
                return mysql_get_proto_info(&mysql_);
        }
 
        std::string query_info();
 
        bool refresh(unsigned options)
        {
                error_message_.clear();
                return !mysql_refresh(&mysql_, options);
        }
 
        bool result_empty()
        {
                error_message_.clear();
                return mysql_field_count(&mysql_) == 0;
        }
 
        bool select_db(const char* db)
        {
                error_message_.clear();
                return !mysql_select_db(&mysql_, db);
        }
 
        std::string server_version()
        {
                error_message_.clear();
                return mysql_get_server_info(&mysql_);
        }
 
        bool set_option(Option* o);
 
        bool set_option(mysql_option moption, const void* arg = 0)
        {
                error_message_.clear();
                return !mysql_options(&mysql_, moption,
                                static_cast<const char*>(arg));
        }
 
        #if MYSQL_VERSION_ID >= 40101
        bool set_option(enum_mysql_set_option msoption)
        {
                error_message_.clear();
                return !mysql_set_server_option(&mysql_, msoption);
        }
        #endif
 
        bool set_option(unsigned int option, bool arg);
 
        bool set_option_default(Option* o)
        {
                const std::type_info& ti = typeid(o);
                for (OptionList::const_iterator it = applied_options_.begin();
                                it != applied_options_.end();
                                ++it) {
                        if (typeid(*it) == ti) {
                                delete o;
                                return "";              // option of this type already set
                        }
                }
 
                return set_option(o);
        }
 
        bool shutdown();
 
        std::string server_status()
        {
                error_message_.clear();
                return mysql_stat(&mysql_);
        }
 
        MYSQL_RES* store_result()
        {
                error_message_.clear();
                return mysql_store_result(&mysql_);
        }
 
        static bool thread_aware();
 
        static void thread_end()
        {
                #if MYSQL_VERSION_ID > 40000            // only in MySQL v4.0 +
                        mysql_thread_end();
                #endif
        }
 
        unsigned long thread_id()
        {
                error_message_.clear();
                return mysql_thread_id(&mysql_);
        }
 
        static bool thread_start()
        {
                #if MYSQL_VERSION_ID > 40000            // only in MySQL v4.0 +
                        return !mysql_thread_init();
                #else
                        return false;
                #endif
        }
 
        MYSQL_RES* use_result()
        {
                error_message_.clear();
                return mysql_use_result(&mysql_);
        }
 
protected:
        bool connect_prepare();
 
        bool set_option_impl(Option* o);
 
private:
        typedef std::deque<Option*> OptionList;
 
        typedef OptionList::iterator OptionListIt;
 
        DBDriver& operator=(const DBDriver&);
 
        MYSQL mysql_;
        bool is_connected_;
        OptionList applied_options_;
        OptionList pending_options_;
        mutable std::string error_message_;
};
 
 
} // end namespace mysqlpp
 
#endif // !defined(MYSQLPP_DBDRIVER_H)