自定义的mysql接口类

代码下载地址：https://download.youkuaiyun.com/download/f110300641/10780482

本类的特点：

1、创建了连接池

2、利用boost的无锁队列，可以高速异步执行sql，不阻塞程序

3、可以根据字段名获得结果

简单的使用例子如下：

创建表格的sql：

CREATE TABLE `student` (
    `no` INT(11) not NULL COMMENT '学号',
    `name` CHAR(11) NOT NULL DEFAULT '' COMMENT '姓名',
    `birtday` TIMESTAMP(3) not NULL DEFAULT CURRENT_TIMESTAMP(3) comment '生日',
    `entern` datetime NULL DEFAULT null,
    `stature` DOUBLE NULL DEFAULT NULL COMMENT '身高',
    primary key (`no`),
    INDEX `birtday` (`birtday`)
)
COMMENT='学生表'
default charset=utf8
COLLATE='utf8_general_ci'
ENGINE=InnoDB
;

 

#include <iostream>
#include <mysql.h>
#include <stdio.h>
#include <mysql.h>
#include <string>
#include <time.h>
#include <random>
#include <thread>
#include <chrono>
#include <string.h>
#include "tg_mysql_result.h"
#include"tg_mysql_common.h"
#include"tg_mysql_connpool.h"

void test()
{
    tg_mysql_param param;
    param.host     = "192.168.0.105";
    param.user     = "root";
    param.pwd      = "root";
    param.dbname   = "test";
    param.charset  = "utf8";
    param.time_out  = 5;
    param.pool_size = 10;

    std::string error;
    //创建连接池
    if ( !g_db_pool.create( param, error ) )
    {
        std::cout<<"线程池创建失败,Err=" << error << std::endl;
        return;
    }

    char sql[1024];
    for(int i=0; i<5; i++)
    {
        memset(sql, 0, sizeof (sql));
        if(i%2==0)
        {
            sprintf(sql, "INSERT INTO `student` (`no`, `name`, `birtday`, `entern`, `stature`) \
                VALUES ('%d', '小白%d', '2013-11-12 09:04:58', '2015-11-12 09:05:10.000', '%f');",
                    i+1,i+1,9.5+i);
        }
        else
        {
            sprintf(sql, "INSERT INTO `student` (`no`, `name`, `birtday`, `stature`) \
                VALUES ('%d', '小白%d', '2013-11-12 09:04:58', '%f');",
                    i+1,i+1,9.5+i);
        }

        if ( !g_db_pool.push(sql))
        {
            std::cout << "Err,Failed to ExecuteSql:" << sql << std::endl;
        }
    }

    std::this_thread::sleep_for(std::chrono::seconds(2));

    memset(sql, 0, sizeof (sql));
    sprintf(sql, "select no, name, entern, stature from student;");
    auto results_ptr = g_db_pool.query(sql, error);
    if (results_ptr)
    {
        printf( "The record count=%ld\n", results_ptr->get_row_count() );

        while ( results_ptr->get_next_row() )
        {
            int no = false;
            results_ptr->try_get_value( "no", no, error );

            std::string name;
            results_ptr->try_get_value( "name", name, error );

            std::string entern;
            results_ptr->try_get_value( "entern", entern, error );

            double stature = 0.0;
            results_ptr->try_get_value( "stature", stature, error );

            int errortmp=-900;
            results_ptr->try_get_value( "error", errortmp, error );

            std::cout << no << " ";
            std::cout << name << " ";
            std::cout << entern << " ";
            std::cout << stature << " ";
            std::cout << errortmp << " ";
            std::cout << std::endl;
        }
    }
}

int main()
{
    test();

    return 0;
}
 

具体类定义：

tg_mysql_common.h

#ifndef TG_MYSQL_COMMON_H
#define TG_MYSQL_COMMON_H

#include<string>
#include <mysql.h>

const int CONST_MYSQL_EXEC_FAILED_COUNT   = 3;//最大异步执行失败次数
const int CONST_MYSQL_QUEQUE_CAPACITY     = 3 * 1024;//异步执行队列最大容量

const int CONST_MYSQL_CONN_MIN = 1;//最小连接数
const int CONST_MYSQL_CONN_MAX = 60;//最大连接数

/**
    * @brief
    数据库连接设置结构体
    */
struct tg_mysql_param
{
    ///数据库主机地址
    std::string host;
    ///用户名
    std::string user;
    ///密码
    std::string pwd;
    ///数据库名
    std::string dbname;
    ///字符集
    std::string charset;

    ///连接数据库超时(单位：秒)
    int time_out;
    ///连接池大小
    uint pool_size;
    tg_mysql_param():time_out(0),pool_size(CONST_MYSQL_CONN_MIN)
    {
    }
};

/**
    * @brief
    异步执行结构体
    */
struct tg_async_sql
{
    int failed_count;//执行失败次数
    std::string sql; //SQ语句
    tg_async_sql(std::string sql):failed_count(0),sql(sql)
    {
    }

    tg_async_sql(const tg_async_sql& data)
    {
        failed_count = data.failed_count;
        sql = data.sql;
    }
};

struct tool_mysql_time
{
    ///把时间字符串转成MYSQL_TIME
    static void str2time(const std::string& str, MYSQL_TIME& out_data)
    {
        sscanf( str.c_str(), "%d-%d-%d %d:%d:%d", &out_data.year, &out_data.month, &out_data.day, &out_data.hour, &out_data.minute, &out_data.second );
        out_data.second_part = 0;//microseconds
        out_data.neg = false;
        out_data.time_type = MYSQL_TIMESTAMP_DATE;
    }
    ///把MYSQL_TIME转成时间字符串
    static std::string time2str( const MYSQL_TIME& value)
    {
        char str[25]={0};
        sprintf( str, "%d-%d-%d %02d:%02d:%02d", value.year, value.month, value.day, value.hour, value.minute, value.second );
        return std::string(str);
    }

    static void clear( MYSQL_TIME& value )
    {
        value.year         = 0;
        value.month        = 0;
        value.day          = 0;
        value.hour         = 0;
        value.minute       = 0;
        value.second       = 0;
        value.neg          = false;
        value.second_part  = 0;
        value.time_type    = MYSQL_TIMESTAMP_DATETIME;
    }
};

#endif // TG_MYSQL_COMMON_H

 

 

tg_mysql_result.h

#ifndef TG_MYSQL_RESULT_H
#define TG_MYSQL_RESULT_H
#include<mysql.h>
#include<map>
#include<tg_mysql_common.h>
#include<string>
#include<memory>
#include<memory.h>

class tg_mysql_result
{
private:
    ///结果集
    MYSQL_RES* _result_ptr;
    ///当前记录行
    MYSQL_ROW _cur_row_ptr;
    ///字段名和字段下标对应列表(key是字段名,value是字段下标)
    std::map<std::string,int> _name_index_map;
public:
    tg_mysql_result(MYSQL_RES *result_ptr):_result_ptr(result_ptr),_cur_row_ptr(nullptr)
    {
        uint field_cout = mysql_num_fields( _result_ptr );
        for ( uint i = 0; i < field_cout; i++ )
        {
            MYSQL_FIELD *field_ptr = mysql_fetch_field_direct( _result_ptr, i );
            if ( nullptr ==  field_ptr )
            {
                continue;
            }

            _name_index_map.insert( std::make_pair( field_ptr->name, i ) );
        }
    }
    ~tg_mysql_result()
    {
        if ( nullptr == _result_ptr )
        {
            return;
        }

        mysql_free_result( _result_ptr );
        _result_ptr = nullptr;
        _cur_row_ptr = nullptr;
        _name_index_map.clear();
    }

    ///获得下一条记录
    bool get_next_row()
    {
        return  ( _cur_row_ptr = mysql_fetch_row( _result_ptr ) ) != nullptr;
    }

    long get_row_count()
    {
        return static_cast<long>(mysql_num_rows( _result_ptr ));
    }

    bool try_get_value( const char * name, int & out_value, std::string & error )
    {
        char* value_ptr = nullptr;
        bool is_null = false;
        if ( !_try_get_value( name, value_ptr, is_null, error ) )
        {
            return false;
        }

        out_value = is_null ? 0 : std::stoi(value_ptr);

        return true;
    }

    bool try_get_value( const char * name, long long & out_value, std::string & error )
    {
        char* value_ptr = nullptr;
        bool is_null = false;
        if ( !_try_get_value( name, value_ptr, is_null, error ) )
        {
            return false;
        }

        out_value = is_null ? 0 : std::stoll(value_ptr);

        return true;
    }

    bool try_get_value( const char * name, std::string & out_value, std::string & error )
    {
        char* value_ptr = nullptr;
        bool is_null = false;
        if ( !_try_get_value( name, value_ptr, is_null, error ) )
        {
            return false;
        }

        out_value = is_null ? "" : value_ptr;

        return true;
    }

    bool try_get_value( const char * name, char * out_value, uint length, std::string & error )
    {
        char* value_ptr = nullptr;
        bool is_null = false;
        if ( !_try_get_value( name, value_ptr, is_null, error ) )
        {
            return false;
        }

        is_null ? memset( out_value, 0, length ) : strncpy( out_value, value_ptr, length );

        return true;
    }

    bool try_get_value( const char * name, bool & out_value, std::string & error )
    {
        char* value_ptr = nullptr;
        bool is_null = false;
        if ( !_try_get_value( name, value_ptr, is_null, error ) )
        {
            return false;
        }

        out_value = is_null ? false : std::stoi(value_ptr);

        return true;
    }

    bool try_get_value( const char * name, float & out_value, std::string & error )
    {
        char* value_ptr = nullptr;
        bool is_null = false;
        if ( !_try_get_value( name, value_ptr, is_null, error ) )
        {
            return false;
        }

        out_value = is_null ? 0 : std::stof(value_ptr);

        return true;
    }

    bool try_get_value( const char * name, double & out_value, std::string & error )
    {
        char* value_ptr = nullptr;
        bool is_null = false;
        if ( !_try_get_value( name, value_ptr, is_null, error ) )
        {
            return false;
        }

        out_value = is_null ? 0 : std::stod(value_ptr);

        return true;
    }

private:
    ///获得原始字符串值
    bool _try_get_value( const char * name, char*& out_ptr, bool& is_null, std::string& error )
    {
        is_null = false;
        int index = -1;
        auto key_value = _name_index_map.find( name );
        if ( _name_index_map.end() != key_value )
        {
            index = key_value->second;
        }
        else
        {
            error = "Error,can't find field name: ";
            error += name;
            return false;
        }

        out_ptr = _cur_row_ptr[index];
        if ( nullptr == out_ptr || 0 == out_ptr[0])
        {
            is_null = true;
        }

        return true;
    }
};

#endif // TG_MYSQL_RESULT_H
 

 

 

 

 

tg_mysql_connect.h

#ifndef TG_MYSQL_CONNECT_H
#define TG_MYSQL_CONNECT_H
#include<mysql.h>
#include<string>
#include<memory>
#include<string.h>
#include"tg_mysql_common.h"
#include"tg_mysql_result.h"

class tg_mysql_connect
{
private:
    MYSQL * _conn_ptr;//数据库连接
    bool _is_temp;//是否是临时的(如果是临时使用的,归还到连接池中时会自动删除,以保持总体连接数不变)

    tg_mysql_param _param;
public:
    uint fail_conn_count;
    tg_mysql_connect(const tg_mysql_param& param, bool is_temp = false ):
        _conn_ptr(nullptr),_is_temp(is_temp),_param(param),fail_conn_count(0)
    {
    }
    ~tg_mysql_connect()
    {
        _close();
    }

    ///连接数据库
    bool connect(std::string & error )
    {
        _close();
        //创建
        _conn_ptr = mysql_init( nullptr );

        //超时设置
        if ( mysql_options( _conn_ptr, MYSQL_OPT_CONNECT_TIMEOUT, &(_param.time_out) ) != 0
             ||mysql_set_character_set( _conn_ptr, _param.charset.c_str() ) != 0
             ||!mysql_real_connect( _conn_ptr, _param.host.c_str(), _param.user.c_str(), _param.pwd.c_str(), _param.dbname.c_str(), 0, nullptr, 0 )
             )
        {
            error = get_last_error();
            return false;
        }

        return true;
    }

    ///测试连接
    bool ping( std::string& error )
    {
        if (mysql_ping( _conn_ptr ) != 0 )
        {
            error = get_last_error();
            return false;
        }

        return true;
    }
    ///设置自动提交
    bool autocommit( bool is_auto, std::string& error )
    {
        if(!mysql_autocommit( _conn_ptr, is_auto ))
        {
            error = get_last_error();
            return false;
        }

        return true;
    }
    ///提交
    bool commit( std::string& error )
    {
        if(!mysql_commit( _conn_ptr ))
        {
            error = get_last_error();
            return false;
        }

        return true;
    }

    bool rollback( std::string& error )
    {
        if(!mysql_rollback( _conn_ptr ))
        {
            error = get_last_error();
            return false;
        }

        return true;
    }

    std::shared_ptr<tg_mysql_result> executequery( const char * sql, std::string& error )
    {
        if (mysql_query( _conn_ptr, sql ) != 0 )
        {
            error = get_last_error();
            return nullptr;
        }

        auto ptr = mysql_store_result( _conn_ptr );
        if(ptr)
        {
            return std::make_shared<tg_mysql_result>(ptr);
        }

        error = get_last_error();
        return nullptr;
    }

    //返回-1 失败
    long executesql( const char * sql, std::string& error )
    {
        long tmp=0;
        if (mysql_query( _conn_ptr, sql ) != 0  || (tmp=static_cast<long>(mysql_affected_rows( _conn_ptr ))) == -1)
        {
            error = get_last_error();
        }

        return tmp;
    }

    //返回-1 失败
    long executerealsql( const char * sql, std::string& error )
    {
        auto len = strlen( sql );
        long tmp=-1;
        if (mysql_real_query( _conn_ptr, sql, len ) != 0  || (tmp=static_cast<long>(mysql_affected_rows( _conn_ptr ))) == -1)
        {
            error = get_last_error();
        }

        return tmp;
    }

    ///获得最后一次错误信息
    const std::string get_last_error()
    {
        if ( nullptr == _conn_ptr )
        {
            return "Error,not connected to database!";
        }

        return std::string(mysql_error( _conn_ptr ));
    }

    ///获得最后一次插入的ID
    long get_last_insert_id( std::string& error )
    {
        if ( nullptr == _conn_ptr )
        {
            error = "Error,not connected to database!";
            return -1;
        }

        return static_cast<long>(mysql_insert_id( _conn_ptr  ));
    }

    ///是否是临时的连接
    bool is_temp()
    {
        return _is_temp;
    }

    void _close()
    {
        if ( _conn_ptr )
        {
            mysql_close( _conn_ptr );
            _conn_ptr = nullptr;
        }
    }
};

#endif // TG_MYSQL_CONNECT_H
 

 

 

 

tg_mysql_connpool.h

#ifndef TG_MYSQL_CONNPOOL_H
#define TG_MYSQL_CONNPOOL_H

#include <boost/bind.hpp>
#include<boost/lockfree/queue.hpp>
#include<boost/chrono.hpp>
#include<mutex>
#include<list>
#include<boost/atomic.hpp>
#include<boost/serialization/singleton.hpp>
#include<boost/thread.hpp>
#include"tg_mysql_common.h"
#include"tg_mysql_connect.h"
#include"tg_mysql_result.h"
#include<memory>
#include<iostream>

class tg_mysql_connpool
{
private:
    ///正在使用的数据库连接
    std::list<std::shared_ptr<tg_mysql_connect>> _busy_list;
    ///没有使用的数据库连接
    std::list<std::shared_ptr<tg_mysql_connect>> _idl_list;
    ///数据库连接参数
    tg_mysql_param _param;
    std::mutex _mutex;

    boost::thread _thread_hand;

    ///异步执行线程用的数据库连接
    std::shared_ptr<tg_mysql_connect> _ansynconn;

    ///异步执行无锁队列
    boost::lockfree::queue<tg_async_sql*, boost::lockfree::capacity<CONST_MYSQL_QUEQUE_CAPACITY>> _queue;

public:
    tg_mysql_connpool():_ansynconn(nullptr)
    {
    }
    ~tg_mysql_connpool()
    {
        _free();
    }

    ///创建数据库连接池
    bool create(const tg_mysql_param& param, std::string& error )
    {
         _free();

        std::unique_lock<std::mutex> lock( _mutex );

        _param = param;
        _deal_pool_size(_param.pool_size);

        for ( uint i = 0; i < _param.pool_size; i++ )
        {
            auto ptr = std::make_shared<tg_mysql_connect>(_param);
            if ( !ptr->connect( error ) )
            {
                return false;
            }

            _idl_list.push_back( ptr );
        }

        //创建异步执行线程
        auto ptr = std::make_shared<tg_mysql_connect>(_param);
        if ( !ptr->connect( error ) )
        {
            return false;
        }
        _ansynconn = ptr;

        //启动异步执行线程
        _thread_hand = boost::thread( &tg_mysql_connpool::_thread_proc, this );

        return true;
    }

    ///把SQL语句加入异步执行队列
    bool push( const std::string& sql )
    {
        tg_async_sql* ptr = new tg_async_sql(sql);
        if(_queue.push(ptr))
        {
            return true;
        }

        _delete(ptr);
        return false;
    }

    std::shared_ptr<tg_mysql_result> query( const char *sql, std::string& error )
    {
        auto ptr = get_connect( error );
        if ( !ptr )
        {
            return nullptr;
        }

        auto result_ptr = ptr->executequery( sql, error );
        give_back(ptr);

        return result_ptr;
    }

    ///失败返回-1
    long executesql( const char *sql, std::string& error )
    {
        auto ptr = get_connect( error );
        if ( !ptr )
        {
            return false;
        }

        auto tmp = ptr->executesql( sql, error );
        give_back(ptr);
        return tmp;
    }

    ///从连接池中获得一个连接
    std::shared_ptr<tg_mysql_connect> get_connect( std::string& error )
    {
        std::unique_lock<std::mutex> lock( _mutex );

        std::shared_ptr<tg_mysql_connect> ptr = nullptr;
        if ( _idl_list.size() > 0 )
        {
            ptr = *(_idl_list.begin());
            _idl_list.pop_front();
            _busy_list.push_back( ptr );
        }
        else
        {
            if ( _busy_list.size() < CONST_MYSQL_CONN_MAX )
            {
                auto ptr = std::make_shared<tg_mysql_connect>(_param, true);
                if ( !ptr->connect( error ) )
                {
                    error = "Error,failed connect to database!";
                    return nullptr;
                }

                _busy_list.push_back( ptr );
            }
            else
            {
                error = "Error,db connect count beyond the max connect count!";
                return nullptr;
            }
        }

        return ptr;
    }
    ///归还连接到连接池
    void give_back( std::shared_ptr<tg_mysql_connect>& ptr )
    {
        std::unique_lock<std::mutex> lock( _mutex );
        _busy_list.remove( ptr );

        //如果是临时连接,不再放入到空闲连接列表中
        if ( !ptr->is_temp() )
        {
            _idl_list.push_back( ptr );
        }
    }

private:
    void _delete(tg_async_sql*& data_ptr)
    {
        if (data_ptr)
        {
            delete data_ptr;
            data_ptr = nullptr;
        }
    }

    void _thread_proc()
    {
        try
        {
            std::string error;
            while( true )
            {
                tg_async_sql* sql_ptr(nullptr);
                while (_queue.pop( sql_ptr )  && sql_ptr)
                {
                    //std::cout<<"执行： " << sql_ptr->sql.c_str()<<std::endl;
                    _thread_proc_sub(sql_ptr,error);

                    _delete(sql_ptr);
                }

                boost::this_thread::sleep_for( boost::chrono::milliseconds( 10 ) );
            }
        }
        catch (boost::thread_interrupted&)
        {
        }
    }

    void _thread_proc_sub(tg_async_sql*& sql_ptr, std::string& error)
    {
        if ( !_ansynconn->executerealsql( sql_ptr->sql.c_str(), error ))//失败
        {
            //std::cout<<"失败： " << sql_ptr->sql.c_str()<<std::endl;
            //如果失败了看是不是数据库断开连接了，尝试重新连接一次
            if ( !_ansynconn->ping( error ) && !_ansynconn->connect( error ))
            {
                if(_ansynconn->fail_conn_count++<CONST_MYSQL_EXEC_FAILED_COUNT)
                {
                    //如果连接失败了休息一下
                    boost::this_thread::sleep_for( boost::chrono::milliseconds( 100 ) );
                }
                else
                {
                    throw error;
                }

            }
            else
            {
                _ansynconn->fail_conn_count=0;
            }

            sql_ptr->failed_count++;
            if ( sql_ptr->failed_count < CONST_MYSQL_EXEC_FAILED_COUNT )
            {
                auto ptr = new tg_async_sql(*sql_ptr);
                _queue.push( ptr );
            }
        }
    }

    static void _deal_pool_size(uint& size)
    {
        size = (size < CONST_MYSQL_CONN_MIN) ? CONST_MYSQL_CONN_MIN : size;
        size = (size > CONST_MYSQL_CONN_MAX) ? CONST_MYSQL_CONN_MAX : size;
    }

    void _free()
    {
        //停止异步执行线程
        if(_thread_hand.joinable())
        {
            _thread_hand.interrupt();
        }

        //把异步执行无锁队列中每个元素释放
        tg_async_sql* data_ptr(nullptr);
        while ( _queue.pop( data_ptr ) )
        {
            _delete (data_ptr);
        }

        _ansynconn=nullptr;
        std::unique_lock<std::mutex> lock( _mutex );
        _busy_list.clear();
        _idl_list.clear();
    }
};

//单件相关定义
typedef boost::serialization::singleton<tg_mysql_connpool> singleton_pool;
#define g_db_pool singleton_pool::get_mutable_instance()
#define g_db_pool_const singleton_pool::get_const_instance()

#endif // TG_MYSQL_CONNPOOL_H