è°â€调整乱码

db/db_api/CDBCommon.h

@@ -1,18 +1,18 @@
 /**
 * @brief
-鏁版嵁搴撳叕鍏卞ご鏂囦欢
+数据库公共头文件
 
 * @version
 V 1.0.0
 
 * @author
-鐜嬬泭淇�
+王益俊
 
 * @date
-鍒涘缓鏃堕棿:  2018-04-19\n
+创建时间:  2018-04-19\n
 
 * @note
-2018-04-19  鍒濇�鍒涘缓銆俓n
+2018-04-19  初次创建。\n
 
 * @warning
 
@@ -27,72 +27,72 @@ V 1.0.0
 
 namespace YADB
 {
-    //----------------------------------------------------------------------------
-	//                                 鏁版嵁搴撻敊璇�畾涔�
 	//----------------------------------------------------------------------------
-	const int DB_ERR_NO_ERROR               = 0;//鏃犻敊璇�
-	const int DB_ERR_NOT_CONNECT_DB         = -1;//鏈�繛鎺ユ暟鎹�簱
-	const int DB_ERR_EXCUTE_QUERY           = -1;//鎵ц�鏌ヨ�澶辫触
-	const int DB_ERR_QUERY_RES_NOT_INITED   = -1;//鏌ヨ�缁撴灉闆嗚繕鏈�垵濮嬪寲
+	//                                 数据库错误定义
+	//----------------------------------------------------------------------------
+	const int DB_ERR_NO_ERROR               = 0;//无错误
+	const int DB_ERR_NOT_CONNECT_DB         = -1;//未连接数据库
+	const int DB_ERR_EXCUTE_QUERY           = -1;//执行查询失败
+	const int DB_ERR_QUERY_RES_NOT_INITED   = -1;//查询结果集还未初始化
 
 	//----------------------------------------------------------------------------
-	//                                 鍏跺畠瀹氫箟
+	//                                 其它定义
 	//----------------------------------------------------------------------------
-	const int MAX_ASYNC_EXEC_FAILED_COUNT   = 3;//鏈€澶у紓姝ユ墽琛屽け璐ユ�鏁�
-	const int MAX_ASYNC_QUEQUE_CAPACITY     = 32 * 1024;//寮傛�鎵ц�闃熷垪鏈€澶у�閲�
+	const int MAX_ASYNC_EXEC_FAILED_COUNT   = 3;//最大异步执行失败次数
+	const int MAX_ASYNC_QUEQUE_CAPACITY     = 32 * 1024;//异步执行队列最大容量
 
 	/**
 	* @brief
-	鏁版嵁搴撹繛鎺ユ暟鏋氫妇
+	数据库连接数枚举
 	*/
 	enum _DB_CONNECT_COUNT_
 	{
-		DCC_MIN_COUNT = 1,//鏈€灏忚繛鎺ユ暟
-		DCC_MAX_COUNT = 60,//鏈€澶ц繛鎺ユ暟
+		DCC_MIN_COUNT = 1,//最小连接数
+		DCC_MAX_COUNT = 60,//最大连接数
 	};
 
 	/**
 	* @brief
-	鏁版嵁搴撹繛鎺ヨ�缃�粨鏋勪綋
+	数据库连接设置结构体
 	*/
-    struct _DB_CONN_SETTING_
+	struct _DB_CONN_SETTING_
 	{
-		unsigned int Port;//绔�彛
-		int TimeOut;//杩炴帴鏁版嵁搴撹秴鏃�(鍗曚綅锛氱�)
-		std::string Host;//鏁版嵁搴撲富鏈哄湴鍧€
-		std::string User;//鐢ㄦ埛鍚�
-		std::string PWD;//瀵嗙爜
-		std::string DBName;//鏁版嵁搴撳悕
-		std::string CharSet;//瀛楃�闆�
-		std::string stmtSQL;//棰勫�鐞哠QL
-		_DB_CONN_SETTING_()
-		{
-			Port    = 3306;
-			TimeOut = 0;
+		unsigned int Port;//端口
+		int TimeOut;//连接数据库超时(单位：秒)
+		std::string Host;//数据库主机地址
+		std::string User;//用户名
+		std::string PWD;//密码
+		std::string DBName;//数据库名
+		std::string CharSet;//字符集
+		std::string stmtSQL;//预处理SQL
+		_DB_CONN_SETTING_()
+		{
+			Port    = 3306;
+			TimeOut = 0;
 		}
 	};
 
 	/**
 	* @brief
-	鏁版嵁搴撹繛鎺ユ睜璁剧疆缁撴瀯浣�
+	数据库连接池设置结构体
 	*/
 	struct _DB_POOL_SETTING_ : public _DB_CONN_SETTING_
 	{
-		int PoolSize;//杩炴帴姹犲ぇ灏�
+		int PoolSize;//连接池大小
 		_DB_POOL_SETTING_()
 		{
 			PoolSize = 0;
 		}
 	};
 
-    /**
-    * @brief
-    寮傛�鎵ц�缁撴瀯浣�
-    */
+	/**
+	* @brief
+	异步执行结构体
+	*/
 	struct _ASYNC_SQL_
 	{
-		int FailedCount;//鎵ц�澶辫触娆℃暟
-		std::string SQL; //SQ璇�彞
+		int FailedCount;//执行失败次数
+		std::string SQL; //SQ语句
 		_ASYNC_SQL_()
 		{
 			FailedCount = 0;
@@ -108,3 +108,4 @@ namespace YADB
 
 
 
+

db/db_api/CDBConnPool.cpp

@@ -1,374 +1,387 @@
-#include "CDBConnPool.h"
-#include <boost/bind.hpp>
-#include <boost/lockfree/queue.hpp>
-
-namespace YADB
-{
-	boost::lockfree::queue<_ASYNC_SQL_*, boost::lockfree::capacity<MAX_ASYNC_QUEQUE_CAPACITY>> __AsyncQueue;//寮傛�鎵ц�鏃犻攣闃熷垪
-
-	CDBConnPool::CDBConnPool()
-	{
-		__pAsyncDBConn = 0;
-	}
-
-	CDBConnPool::~CDBConnPool()
-	{
-		Close();
-	}
-
-	CDBConnect * CDBConnPool::__CreateIdleConn( std::string& Error, bool IsTemp )
-	{
-		std::string ConnErr;
-
-		_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
-		CDBConnect* pConn = new CDBConnect( IsTemp );
-		if ( !pConn->Connect( ConnSetting, ConnErr ) )
-		{
-			delete pConn;
-			pConn = 0;
-			return 0;
-		}
-
-		//濡傛灉璁剧疆浜嗛�澶勭悊SQL瑕佸噯澶囬�澶勭悊
-		if ( !ConnSetting.stmtSQL.empty() )
-		{
-			if ( !pConn->Preparestmt( ConnSetting.stmtSQL.c_str(), Error ) )
-			{
-				delete pConn;
-				pConn = 0;
-				return 0;
-			}
-		}
-
-		__IdleConnList.push_back( pConn );
-		return pConn;
-	}
-
-	bool CDBConnPool::Create( const _DB_POOL_SETTING_& Setting, std::string& Error )
-	{
-		std::unique_lock<std::mutex> lock( __mtx );
-
-		if ( Setting.PoolSize < DCC_MIN_COUNT )
-		{
-			Error = "PoolSize is too small!";
-			return false;
-		}
-
-		if ( Setting.PoolSize > DCC_MAX_COUNT )
-		{
-			Error = "PoolSize is too big!";
-			return false;
-		}
-
-		__Setting = Setting;
-		std::string ConnErr;
-		for ( int i = 0; i < __Setting.PoolSize; i++ )
-		{
-			CDBConnect* pConn = __CreateIdleConn( Error );
-			if ( !pConn )
-			{
-				return false;
-			}
-		}
-
-		//鍒涘缓寮傛�鎵ц�绾跨▼
-		__CreateAsyncThrdConn();
-
-		//鍚�姩寮傛�鎵ц�绾跨▼
-		__StartAsyncThrd();
-
-		return true;
-	}
-
-	void CDBConnPool::Close()
-	{
-		std::unique_lock<std::mutex> lock( __mtx );
-
-		//鍋滄�寮傛�鎵ц�绾跨▼
-		__StopAsyncThrd();
-
-		//鍒�櫎寮傛�鎵ц�绾跨▼杩炴帴
-		__DestroyAsyncThrdConn();
-
-		//鎶婃墍鏈夊垪琛ㄤ腑鐨勮繛鎺ュ�璞￠兘鍏抽棴鍒犻櫎骞舵竻闄ゅ垪琛�
-		CDBConnect* pConn = 0;
-		std::list<CDBConnect*>::iterator lit_conn;
-		for ( lit_conn = __BusyConnList.begin(); lit_conn != __BusyConnList.end(); lit_conn++ )
-		{
-			pConn = *lit_conn;
-			pConn->Close();
-			delete pConn;
-			pConn = 0;
-		}
-		__BusyConnList.clear();
-
-		for ( lit_conn = __IdleConnList.begin(); lit_conn != __IdleConnList.end(); lit_conn++ )
-		{
-			pConn = *lit_conn;
-			pConn->Close();
-			delete pConn;
-			pConn = 0;
-		}
-		__IdleConnList.clear();
-	}
-
-	CDBConnect * CDBConnPool::GetDBConnect( std::string& Error )
-	{
-		std::unique_lock<std::mutex> lock( __mtx );
-
-		CDBConnect* pConn = 0;
-
-		if ( __IdleConnList.size() > 0 )
-		{
-			pConn = *(__IdleConnList.begin());
-			__IdleConnList.pop_front();
-			__BusyConnList.push_back( pConn );
-		}
-		else
-		{
-			//濡傛灉宸茬粡娌℃湁绌洪棽杩炴帴,鍙��褰撳墠杩炴帴姹犳暟閲忔病鏈夎秴杩囨渶澶ц繛鎺ユ暟灏卞垱寤轰竴涓�复鏃惰繛鎺�
-			if ( __IdleConnList.size() < DCC_MAX_COUNT )
-			{
-				pConn = __CreateIdleConn( Error, true );
-				if ( !pConn )
-				{
-					Error = "Error,failed connect to database!";
-					return 0;
-				}
-
-				__IdleConnList.pop_front();
-				__BusyConnList.push_back( pConn );
-			}
-			else
-			{
-				Error = "Error,db connect count beyond the max connect count!";
-				return 0;
-			}
-		}
-
-		//楠岃瘉鐪嬫暟鎹�簱杩炴帴鏄�惁杩樻湁鏁�
-		if ( pConn )
-		{
-			if ( pConn->ConnctionTest( Error ) != 0 )
-			{
-				//閲嶈繛涓€娆�
-				_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
-				pConn->Close();
-				int nRet = pConn->Connect( ConnSetting, Error );
-				if ( nRet < 0 )
-				{
-					GiveBack( pConn );
-					Error = "Error,failed connect to database!";
-					return 0;
-				}
-			}
-		}
-
-		return pConn;
-	}
-
-	void CDBConnPool::GiveBack( CDBConnect * pConn )
-	{
-		std::unique_lock<std::mutex> lock( __mtx );
-
-		if ( 0 == pConn )
-		{
-			return;
-		}
-
-		__BusyConnList.remove( pConn );
-
-		//濡傛灉鏄�复鏃惰繛鎺�,鐩存帴鍒犻櫎涓嶅啀鏀惧叆鍒扮┖闂茶繛鎺ュ垪琛ㄤ腑
-		if ( pConn->IsTemp() )
-		{
-			delete pConn;
-			pConn = 0;
-		}
-		else
-		{
-			__IdleConnList.push_back( pConn );
-		}
-	}
-
-	void CDBConnPool::_AsyncThreadFunc( CDBConnPool* pOwner )
-	{
-		std::string Error;
-		while( pOwner->__Running )
-		{
-			_ASYNC_SQL_* pData = 0;
-			while ( __AsyncQueue.pop( pData ) )
-			{
-				if ( pData )
-				{
-					if ( __pAsyncDBConn )
-					{
-						my_ulonglong llRes = 0;
-						llRes = __pAsyncDBConn->ExecuteRealSql( pData->SQL.c_str(), Error );
-						if ( -1 == llRes )
-						{
-							//Execute failed, write log...
-							printf( "Error,璋冪敤ExcuteRealSql澶辫触,Err=%s\n", Error.c_str() );
-							//濡傛灉澶辫触浜嗙湅鏄�笉鏄�暟鎹�簱鏂�紑杩炴帴浜嗭紝灏濊瘯閲嶆柊杩炴帴涓€娆�
-							if ( __pAsyncDBConn->ConnctionTest( Error ) != 0 )
-							{
-								_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
-								__pAsyncDBConn->Close();
-								int nRet = __pAsyncDBConn->Connect( ConnSetting, Error );
-								if ( nRet < 0 )
-								{
-									Error = "Error,failed connect to database!";
-									//Connect failed, write log...
-									printf( "Error,failed connect to database,Err=%s\n", Error.c_str() );
-									//濡傛灉杩炴帴澶辫触浜嗕紤鎭�竴涓�
-									boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) );
-								}
-							}
-
-							//濡傛灉鎵ц�澶辫触锛屽け璐ユ�鏁板姞涓€锛屽け璐ユ�鏁板皬浜庢渶澶уけ璐ユ�鏁版斁鍒伴槦灏句笅娆″啀鎵ц�
-							pData->FailedCount++;
-							if ( pData->FailedCount < MAX_ASYNC_EXEC_FAILED_COUNT )
-							{
-								_ASYNC_SQL_* pNewData = new _ASYNC_SQL_();
-								pNewData->FailedCount = pData->FailedCount;
-								pNewData->SQL         = pData->SQL;
-								__AsyncQueue.push( pNewData );
-							}
-						}
-					}
-
-					delete pData;
-					pData = 0;
-				}
-			}
-
-			boost::this_thread::sleep_for( boost::chrono::milliseconds( 1 ) );
-		}
-
-		//绾跨▼閫€鍑�
-		__IsExited = true;
-	}
-
-	void CDBConnPool::__StopAsyncThrd()
-	{
-		if ( !__Running )
-		{
-			return;
-		}
-
-		//绛夊緟寮傛�鎵ц�绾跨▼閫€鍑�
-		__Running = false;
-
-		while ( !__IsExited )
-		{
-			boost::this_thread::sleep_for( boost::chrono::milliseconds( 1 ) );
-		}
-
-		//鎶婂紓姝ユ墽琛屾棤閿侀槦鍒椾腑姣忎釜鍏冪礌閲婃斁
-		_ASYNC_SQL_* pData = 0;
-		while ( __AsyncQueue.pop( pData ) )
-		{
-			if (pData)
-			{
-				delete pData;
-				pData = 0;
-			}
-		}
-	}
-
-	void CDBConnPool::__StartAsyncThrd()
-	{
-		boost::thread thrd( boost::bind( &CDBConnPool::_AsyncThreadFunc, this, this ) );
-		thrd.detach();
-	}
-
-	void CDBConnPool::__CreateAsyncThrdConn()
-	{
-		std::string ConnErr;
-
-		_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
-		CDBConnect* pConn = new CDBConnect();
-		if ( !pConn->Connect( ConnSetting, ConnErr ) )
-		{
-			delete pConn;
-			pConn = 0;
-			return;
-		}
-
-		__pAsyncDBConn = pConn;
-	}
-
-	void CDBConnPool::__DestroyAsyncThrdConn()
-	{
-		if ( __pAsyncDBConn )
-		{
-			__pAsyncDBConn->Close();
-			delete __pAsyncDBConn;
-			__pAsyncDBConn = 0;
-		}
-	}
-
-	bool CDBConnPool::PushAsync( const std::string& strSQL )
-	{
-		_ASYNC_SQL_* pData = new _ASYNC_SQL_;
-		if ( !pData )
-		{
-			return false;
-		}
-
-		pData->SQL = strSQL;
-		return __AsyncQueue.push( pData );
-	}
-
-	bool CDBConnPool::Query( const char *szSql, CDBResultSet& DBRes, std::string& Error )
-	{
-		CDBConnect *pConn = GetDBConnect( Error );
-		if ( 0 == pConn )
-		{
-			return false;
-		}
-
-		MYSQL_RES* pRes = pConn->Query( szSql, Error );
-		GiveBack( pConn );
-		return DBRes.Bind( pRes, Error );
-	}
-
-	MYSQL_RES* CDBConnPool::Query( const char *szSql, std::string& Error )
-	{
-		CDBConnect *pConn = GetDBConnect( Error );
-		if ( 0 == pConn )
-		{
-			return false;
-		}
-
-		MYSQL_RES* pRes = pConn->Query( szSql, Error );
-		GiveBack( pConn );
-		return pRes;
-	}
-
-	my_ulonglong CDBConnPool::ExecuteSql( const char *szSql, std::string& Error )
-	{
-		CDBConnect *pConn = GetDBConnect( Error );
-		if ( 0 == pConn )
-		{
-			return -1;
-		}
-
-		my_ulonglong nRet = pConn->ExecuteSql( szSql, Error );
-		GiveBack( pConn );
-		return nRet;
-	}
-
-	my_ulonglong CDBConnPool::ExecuteSqlID( const char * szSql, std::string & Error )
-	{
-		CDBConnect *pConn = GetDBConnect( Error );
-		if ( 0 == pConn )
-		{
-			return -1;
-		}
-
-		my_ulonglong nRet = pConn->ExecuteSqlID( szSql, Error );
-
-		GiveBack( pConn );
-		return nRet;
-	}
-}
+#include "CDBConnPool.h"
+#include <boost/bind.hpp>
+
+namespace YADB
+{
+	boost::lockfree::queue<_ASYNC_SQL_*, boost::lockfree::capacity<MAX_ASYNC_QUEQUE_CAPACITY>> __AsyncQueue;//异步执行无锁队列
+
+	CDBConnPool::CDBConnPool()
+	{
+		__pAsyncDBConn = 0;
+	}
+
+	CDBConnPool::~CDBConnPool()
+	{
+		Close();
+	}
+
+	CDBConnect * CDBConnPool::__CreateIdleConn( std::string& ConnErr, bool IsTemp )
+	{
+		//std::string ConnErr;
+
+		_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
+		CDBConnect* pConn = new CDBConnect( IsTemp );
+		if ( !pConn->Connect( ConnSetting, ConnErr ) )
+		{
+			delete pConn;
+			pConn = 0;
+			return 0;
+		}
+
+		//如果设置了预处理SQL要准备预处理
+		if ( !ConnSetting.stmtSQL.empty() )
+		{
+			if ( !pConn->Preparestmt( ConnSetting.stmtSQL.c_str(), ConnErr ) )
+			{
+				delete pConn;
+				pConn = 0;
+				return 0;
+			}
+		}
+
+		__IdleConnList.push_back( pConn );
+		return pConn;
+	}
+
+	bool CDBConnPool::Create( const _DB_POOL_SETTING_& Setting, std::string& szError )
+	{
+		return Create(Setting,true,szError);
+	}
+
+	bool CDBConnPool::Create( const _DB_POOL_SETTING_& Setting,bool bAsync, std::string& szError )
+	{
+		std::unique_lock<std::mutex> lock( __mtx );
+
+		if ( Setting.PoolSize < DCC_MIN_COUNT )
+		{
+			szError = "PoolSize is too small!";
+			return false;
+		}
+
+		if ( Setting.PoolSize > DCC_MAX_COUNT )
+		{
+			szError = "PoolSize is too big!";
+			return false;
+		}
+
+		__Setting = Setting;
+		//检查连接池中是否已有连接数量
+		if ((int)__IdleConnList.size() < __Setting.PoolSize)
+		{
+			for ( int i = 0; i < __Setting.PoolSize; i++ )
+			{
+				CDBConnect* pConn = __CreateIdleConn( szError );
+				if ( !pConn )
+				{
+					return false;
+				}
+			}	
+		}
+		//是否已创建异步线程
+		if (bAsync || !__Running)
+		{
+			//创建异步执行线程
+			__CreateAsyncThrdConn();
+
+			//启动异步执行线程
+			__StartAsyncThrd();
+		}		
+		return true;
+	}
+
+	void CDBConnPool::Close()
+	{
+		std::unique_lock<std::mutex> lock( __mtx );
+
+		//停止异步执行线程
+		__StopAsyncThrd();
+
+		//??????????步执行线程连接
+		__DestroyAsyncThrdConn();
+
+		//把所有列表中的连接对象都关闭删除并清除列表
+		CDBConnect* pConn = 0;
+		std::list<CDBConnect*>::iterator lit_conn;
+		for ( lit_conn = __BusyConnList.begin(); lit_conn != __BusyConnList.end(); lit_conn++ )
+		{
+			pConn = *lit_conn;
+			pConn->Close();
+			delete pConn;
+			pConn = 0;
+		}
+		__BusyConnList.clear();
+
+		for ( lit_conn = __IdleConnList.begin(); lit_conn != __IdleConnList.end(); lit_conn++ )
+		{
+			pConn = *lit_conn;
+			pConn->Close();
+			delete pConn;
+			pConn = 0;
+		}
+		__IdleConnList.clear();
+	}
+
+	CDBConnect * CDBConnPool::GetDBConnect( std::string& Error )
+	{
+		std::unique_lock<std::mutex> lock( __mtx );
+
+		CDBConnect* pConn = 0;
+
+		if ( __IdleConnList.size() > 0 )
+		{
+			pConn = *(__IdleConnList.begin());
+			__IdleConnList.pop_front();
+			__BusyConnList.push_back( pConn );
+		}
+		else
+		{
+			//如果已经没有空闲连接,只要当前连接池数量没有超过最大连接数就创建一个临时连接
+			//这个判断无意义
+			if ( __IdleConnList.size() < DCC_MAX_COUNT )
+			{
+				pConn = __CreateIdleConn( Error, true );
+				if ( !pConn )
+				{
+					Error = "Error,failed connect to database!";
+					return 0;
+				}
+
+				__IdleConnList.pop_front();
+				__BusyConnList.push_back( pConn );
+			}
+			else
+			{
+				Error = "Error,db connect count beyond the max connect count!";
+				return 0;
+			}
+		}
+
+		//验证看数据库连接是否还有效
+		if ( pConn )
+		{
+			if ( pConn->ConnctionTest( Error ) != 0 )
+			{
+				//重连一次
+				_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
+				pConn->Close();
+				int nRet = pConn->Connect( ConnSetting, Error );
+				if ( nRet < 0 )
+				{
+					GiveBack( pConn );
+					Error = "Error,failed connect to database!";
+					return 0;
+				}
+			}
+		}
+
+		return pConn;
+	}
+
+	void CDBConnPool::GiveBack( CDBConnect * pConn )
+	{
+		std::unique_lock<std::mutex> lock( __mtx );
+
+		if ( 0 == pConn )
+		{
+			return;
+		}
+
+		__BusyConnList.remove( pConn );
+
+		//如果是临时连接,直接删除不再放入到空闲连接列表中
+		if ( pConn->IsTemp() )
+		{
+			delete pConn;
+			pConn = 0;
+		}
+		else
+		{
+			__IdleConnList.push_back( pConn );
+		}
+	}
+
+	void CDBConnPool::_AsyncThreadFunc( CDBConnPool* pOwner )
+	{
+		std::string Error;
+		while( pOwner->__Running )
+		{
+			_ASYNC_SQL_* pData = 0;
+
+			while ( __AsyncQueue.pop( pData ) )
+			{
+				if ( pData )
+				{
+					if ( __pAsyncDBConn )
+					{
+						my_ulonglong llRes = 0;
+						llRes = __pAsyncDBConn->ExecuteRealSql( pData->SQL.c_str(), Error ); 
+						if ( (my_ulonglong)-1 == llRes )
+						{
+							//Execute failed, write log...
+							printf( "Error,调用ExcuteRealSql失败,Err=%s\n", Error.c_str() );
+							//如果失败了看是不是数据库断开连接了，尝试重新连接一次
+							if ( __pAsyncDBConn->ConnctionTest( Error ) != 0 )
+							{
+								_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
+								__pAsyncDBConn->Close();
+								int nRet = __pAsyncDBConn->Connect( ConnSetting, Error );
+								if ( nRet < 0 )
+								{
+									Error = "Error,failed connect to database!";
+									//Connect failed, write log...
+									printf( "Error,failed connect to database,Err=%s\n", Error.c_str() );
+									//如果连接失败了休息一下
+									boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) );
+								}
+							}
+
+							//如果执行失败，失败次数加一，失败次数小于最大失败次数放到队尾下次再执行
+							pData->FailedCount++;
+							if ( pData->FailedCount < MAX_ASYNC_EXEC_FAILED_COUNT )
+							{
+								_ASYNC_SQL_* pNewData = new _ASYNC_SQL_();
+								pNewData->FailedCount = pData->FailedCount;
+								pNewData->SQL         = pData->SQL;
+								__AsyncQueue.push( pNewData );
+							}
+						}
+					}
+
+					delete pData;
+					pData = 0;
+				}
+			}
+
+			boost::this_thread::sleep_for( boost::chrono::milliseconds( 1 ) );
+		}
+
+		//线程退出
+		__IsExited = true;
+	}
+
+	void CDBConnPool::__StopAsyncThrd()
+	{
+		if ( !__Running )
+		{
+			return;
+		}
+
+		//等待异步执行线程退出
+		__Running = false;
+
+		while ( !__IsExited )
+		{
+			boost::this_thread::sleep(boost::posix_time::millisec(1));
+		}
+
+		//把异步执行无锁队列中每个元素释放
+		_ASYNC_SQL_* pData = 0;
+		while ( __AsyncQueue.pop( pData ) )
+		{
+			if (pData)
+			{
+				delete pData;
+				pData = 0;
+			}
+		}
+	}
+
+	void CDBConnPool::__StartAsyncThrd()
+	{
+		__Running = true;
+		boost::thread thrd( boost::bind( &CDBConnPool::_AsyncThreadFunc, this, this ) );
+		thrd.detach();
+	}
+
+	void CDBConnPool::__CreateAsyncThrdConn()
+	{
+		std::string ConnErr;
+		//先断开之前的连接
+		this->__DestroyAsyncThrdConn();
+
+		_DB_CONN_SETTING_ ConnSetting = static_cast< _DB_CONN_SETTING_ >(__Setting);
+		CDBConnect* pConn = new CDBConnect();
+		if ( !pConn->Connect( ConnSetting, ConnErr ) )
+		{
+			delete pConn;
+			pConn = 0;
+			return;
+		}
+
+		__pAsyncDBConn = pConn;
+	}
+
+	void CDBConnPool::__DestroyAsyncThrdConn()
+	{
+		if ( __pAsyncDBConn )
+		{
+			__pAsyncDBConn->Close();
+			delete __pAsyncDBConn;
+			__pAsyncDBConn = 0;
+		}
+	}
+
+	bool CDBConnPool::PushAsync( const std::string& strSQL )
+	{
+		_ASYNC_SQL_* pData = new _ASYNC_SQL_;
+		if ( !pData )
+		{
+			return false;
+		}
+
+		pData->SQL = strSQL;
+		return __AsyncQueue.push( pData );
+	}
+
+	bool CDBConnPool::Query( const char *szSql, CDBResultSet& DBRes,std::string& Error )
+	{
+		CDBConnect *pConn = GetDBConnect( Error );
+		if ( 0 == pConn )
+		{
+			return false;
+		}
+
+		MYSQL_RES* pRes = pConn->Query( szSql, Error );
+		GiveBack( pConn );
+		return DBRes.Bind( pRes, Error );
+	}
+
+	MYSQL_RES* CDBConnPool::Query( const char *szSql, std::string& Error)
+	{
+		CDBConnect *pConn = GetDBConnect(Error);
+		if( 0 == pConn){
+			return nullptr;
+		}
+
+		MYSQL_RES* pRes = pConn->Query(szSql,Error);
+		GiveBack(pConn);
+		return pRes;
+	}
+	my_ulonglong CDBConnPool::ExecuteSql( const char *szSql, std::string& Error )
+	{
+		CDBConnect *pConn = GetDBConnect( Error );
+		if ( 0 == pConn )
+		{
+			return -1;
+		}
+		my_ulonglong nRet = pConn->ExecuteSql( szSql, Error );
+		GiveBack( pConn );
+		return nRet;
+		//return pConn->ExecuteSql( szSql, Error );
+	}
+
+	my_ulonglong CDBConnPool::ExecuteSqlID( const char * szSql, std::string & Error )
+	{
+		CDBConnect *pConn = GetDBConnect( Error );
+		if ( 0 == pConn )
+		{
+			return -1;
+		}
+
+		my_ulonglong nRet = pConn->ExecuteSqlID( szSql, Error );
+
+		GiveBack( pConn );
+		return nRet;
+	}
+}
+

db/db_api/CDBConnPool.h

@@ -1,7 +1,7 @@
-#ifndef CDBConnPool_h__
-#define CDBConnPool_h__
-
-
+#ifndef CDBConnPool_h__
+#define CDBConnPool_h__
+
+
 /**
 * @brief
 数据库连接池类
@@ -23,25 +23,25 @@ V 1.0.0
 * @bug
 
 */
-
-#pragma once
-
-#include <boost/atomic.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/serialization/singleton.hpp>
-
-#include <list>
-#include <string>
-#include <mutex>
-
-#include "CDBCommon.h"
-#include "CDBConnect.h"
-
-namespace YADB
-{
-	class CDBConnPool
-	{
-	private:
+
+#pragma once
+
+#include <boost/atomic.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/lockfree/queue.hpp>
+
+#include <list>
+#include <string>
+#include <mutex>
+
+#include "CDBCommon.h"
+#include "CDBConnect.h"
+
+namespace YADB
+{
+	class CDBConnPool
+	{
+	private:
 		std::list<CDBConnect*> __BusyConnList;//正在使用的数据库连接列表
 		std::list<CDBConnect*> __IdleConnList;//没有使用的数据库连接列表
 		_DB_POOL_SETTING_ __Setting;//数据库连接池设置
@@ -49,7 +49,7 @@ namespace YADB
 		boost::atomic<bool> __Running{ true };//线程是否运行的标识		
 		boost::atomic<bool> __IsExited{ false };//线程是否已退出的标识
 		CDBConnect* __pAsyncDBConn;//异步执行线程用的数据库连接
-	private:
+	private:
 		/**
 
 		* @brief
@@ -67,9 +67,9 @@ namespace YADB
 		* @bug
 
 		*/
-		CDBConnect* __CreateIdleConn( std::string& Error, bool IsTemp = false );
-		/**
-		* @brief
+		CDBConnect* __CreateIdleConn( std::string& Error, bool IsTemp = false );
+		/**
+		* @brief
 		创建异步执行线程所用连接函数。
 
 		* @param  无\n
@@ -81,8 +81,8 @@ namespace YADB
 		* @warning
 
 		* @bug
-		*/
-		void __CreateAsyncThrdConn();
+		*/
+		void __CreateAsyncThrdConn();
 		/**
 		* @brief
 		??????创建异步执行线程所用连接函数。
@@ -98,7 +98,7 @@ namespace YADB
 		* @bug
 
 		*/
-		void __DestroyAsyncThrdConn();
+		void __DestroyAsyncThrdConn();
 		/**
 		* @brief
 		启动异步执行线程函数。
@@ -114,7 +114,7 @@ namespace YADB
 		* @bug
 
 		*/
-		void __StartAsyncThrd();
+		void __StartAsyncThrd();
 		/**
 		* @brief
 		停止异步执行线程函数。
@@ -130,8 +130,8 @@ namespace YADB
 		* @bug
 
 		*/
-		void __StopAsyncThrd();
-	protected:
+		void __StopAsyncThrd();
+	protected:
 		/**
 		* @brief
 		异步执行线程函数。
@@ -148,9 +148,9 @@ namespace YADB
 
 		*/
 		void _AsyncThreadFunc( CDBConnPool* pOwner );//线程函数
-	public:
-		CDBConnPool();
-		~CDBConnPool();
+	public:
+		CDBConnPool();
+		~CDBConnPool();
 		/**
 		* @brief
 		创建数据库连接池函数。
@@ -169,7 +169,8 @@ namespace YADB
 		* @bug
 
 		*/
-		bool Create( const _DB_POOL_SETTING_& Setting, std::string& Error );
+		bool Create( const _DB_POOL_SETTING_& Setting, std::string& Error );
+		bool Create( const _DB_POOL_SETTING_& Setting,bool bAsync, std::string& szError );
 		/**
 		* @brief
 		关闭线程池函数。
@@ -185,7 +186,7 @@ namespace YADB
 		* @bug
 
 		*/
-		void Close();
+		void Close();
 		/**
 		* @brief
 		从连接池中获得一个数据库连接函数。
@@ -203,7 +204,7 @@ namespace YADB
 		* @bug
 
 		*/
-		CDBConnect* GetDBConnect( std::string& Error );
+		CDBConnect* GetDBConnect( std::string& Error );
 		/**
 		* @brief
 		归还一个数据库连接到连接池中函数。
@@ -219,7 +220,7 @@ namespace YADB
 		* @bug
 
 		*/
-		void GiveBack( CDBConnect* pConn );
+		void GiveBack( CDBConnect* pConn );
 		/**
 		* @brief
 		把SQL语句加入异步执行队列函数。
@@ -237,7 +238,7 @@ namespace YADB
 		* @bug
 
 		*/
-		bool PushAsync( const std::string& strSQL );
+		bool PushAsync( const std::string& strSQL );
 		/**
 		* @brief
 		执行SQL语句返回结果集函数。
@@ -257,24 +258,8 @@ namespace YADB
 		* @bug
 
 		*/
-		bool Query( const char *szSql, CDBResultSet& DBRes, std::string& Error );
-		/**
-		* @brief
-		执行SQL语句返回原生结果集函数。
-
-		* @param [in] const char *szSql  SQL语句\n
-		* @param [out] std::string& Error  错误信息\n
-
-		* @return 返回查询的结果集
-
-		* @note
-
-		* @warning
-
-		* @bug
-
-		*/
-		MYSQL_RES* Query( const char *szSql, std::string& Error );
+		bool Query( const char *szSql, CDBResultSet& DBRes, std::string& Error );
+		MYSQL_RES* Query( const char *szSql, std::string& Error );
 		/**
 		* @brief
 		执行SQL语句函数。
@@ -293,7 +278,7 @@ namespace YADB
 		* @bug
 
 		*/
-		my_ulonglong ExecuteSql( const char *szSql, std::string& Error );
+		my_ulonglong ExecuteSql( const char *szSql, std::string& Error );
 		/**
 		* @brief
 		执行SQL语句并获得ID的函数。
@@ -312,12 +297,8 @@ namespace YADB
 		* @bug
 
 		*/
-		my_ulonglong ExecuteSqlID( const char *szSql, std::string& Error );
-	};
-}
-
-//单件相关定义
-typedef boost::serialization::singleton<YADB::CDBConnPool> singleton_CDBConnPool;
-#define sDBConnPool singleton_CDBConnPool::get_mutable_instance()
-
+		my_ulonglong ExecuteSqlID( const char *szSql, std::string& Error );
+	};
+}
 #endif // CDBConnPool_h__
+

db/db_api/CDBConnect.cpp

@@ -18,10 +18,10 @@ namespace YADB
 
 	bool CDBConnect::Connect( const _DB_CONN_SETTING_ & DBSetting, std::string & Error )
 	{
-		//鍒涘缓
+		//创建
 		__pConn = mysql_init( NULL );
 
-		//瓒呮椂璁剧疆
+		//超时设置
 		if ( mysql_options( __pConn, MYSQL_OPT_CONNECT_TIMEOUT, &(DBSetting.TimeOut) ) != 0 )
 		{
 			Error = "Failed to call mysql_options,";
@@ -30,7 +30,7 @@ namespace YADB
 			return false;
 		}
 
-		//璁剧疆瀛楃�闆�
+		//设置字符集
 		if ( mysql_set_character_set( __pConn, DBSetting.CharSet.c_str() ) != 0 )
 		{
 			Error = "Failed to call mysql_set_character_set,";
@@ -39,7 +39,7 @@ namespace YADB
 			return false;
 		}
 
-		//杩炴帴鏁版嵁搴�
+		//连接数据库
 		if ( !mysql_real_connect( __pConn, DBSetting.Host.c_str(), DBSetting.User.c_str(), DBSetting.PWD.c_str(), DBSetting.DBName.c_str(), 0, NULL, 0 ) )
 		{
 			Error = "Failed to connect database,";
@@ -47,7 +47,7 @@ namespace YADB
 			Error += GetLastError();
 			return false;
 		}
-		//渚濋潬 mysql_ping 鏃犳硶鍋氬埌閲嶈繛
+		//依靠 mysql_ping 无法做到重连
 		char value = 1;
 		mysql_options(__pConn, MYSQL_OPT_RECONNECT, &value);
 
@@ -182,24 +182,6 @@ namespace YADB
 
 		return mysql_affected_rows( __pConn );
 	}
-	my_ulonglong CDBConnect::ExecuteSqlID( const char * szSql, std::string & Error )
-	{
-		if ( 0 == __pConn )
-		{
-			Error = "Error,not connected to database!";
-			return DB_ERR_NOT_CONNECT_DB;
-		}
-
-		if ( mysql_real_query( __pConn, szSql, strlen( szSql ) ) )
-		{
-			Error = "Failed to execute SQL!";
-			Error += " LastError=";
-			Error += GetLastError();
-			return DB_ERR_EXCUTE_QUERY;
-		}
-
-		return mysql_insert_id( __pConn );
-	}
 
 	my_ulonglong CDBConnect::ExecuteRealSql( const char * szSql, std::string & Error )
 	{
@@ -308,4 +290,24 @@ namespace YADB
 			__pstmt = 0;
 		}
 	}
+
+	my_ulonglong CDBConnect::ExecuteSqlID( const char * szSql, std::string & Error )
+	{
+		if ( 0 == __pConn )
+		{
+			Error = "Error,not connected to database!";
+			return DB_ERR_NOT_CONNECT_DB;
+		}
+
+		if ( mysql_real_query( __pConn, szSql, strlen( szSql ) ) )
+		{
+			Error = "Failed to execute SQL!";
+			Error += " LastError=";
+			Error += GetLastError();
+			return DB_ERR_EXCUTE_QUERY;
+		}
+
+		return mysql_insert_id( __pConn );
+	}
 }
+

db/db_api/CDBConnect.h

@@ -1,18 +1,18 @@
 /**
 * @brief
-鏁版嵁搴撹繛鎺ョ被
+数据库连接类
 
 * @version
 V 1.0.0
 
 * @author
-鐜嬬泭淇�
+王益俊
 
 * @date
-鍒涘缓鏃堕棿:  2018-04-17\n
+创建时间:  2018-04-17\n
 
 * @note
-2018-04-17  鍒涘缓绫汇€俓n
+2018-04-17  创建类。\n
 
 * @warning
 
@@ -32,23 +32,23 @@ namespace YADB
 	class CDBConnect
 	{
 	private:
-    	MYSQL * __pConn;//鏁版嵁搴撹繛鎺�
-    	CDBResultSet __RessultSet;//缁撴灉闆�
-    	bool __IsTemp;//鏄�惁鏄�复鏃剁殑(濡傛灉鏄�复鏃朵娇鐢ㄧ殑,褰掕繕鍒拌繛鎺ユ睜涓�椂浼氳嚜鍔ㄥ垹闄�,浠ヤ繚鎸佹€讳綋杩炴帴鏁颁笉鍙�)
-    	MYSQL_STMT *__pstmt;//棰勫�鐞�
+		MYSQL * __pConn;//数据库连接
+		CDBResultSet __RessultSet;//结果集
+		bool __IsTemp;//是否是临时的(如果是临时使用的,归还到连接池中时会自动删除,以保持总体连接数不变)
+		MYSQL_STMT *__pstmt;//预处理
 	public:
 		CDBConnect( bool IsTemp = false );
 		~CDBConnect();
 		/**
 		* @brief
-		杩炴帴鏁版嵁搴撳嚱鏁般€�
+		连接数据库函数。
 
-		* @param  [in] const _DB_POOL_SETTING_& Setting  鏁版嵁搴撹繛鎺ヨ�缃甛n
-		* @param  [out] std::string& Error  閿欒�淇℃伅\n
+		* @param  [in] const _DB_POOL_SETTING_& Setting  数据库连接设置\n
+		* @param  [out] std::string& Error  错误信息\n
 
-		* @return 杩斿洖杩炴帴鏁版嵁搴撴槸鍚︽垚鍔�
-		* @return  true   鎴愬姛\n
-		* @return  false  澶辫触\n
+		* @return 返回连接数据库是否成功
+		* @return  true   成功\n
+		* @return  false  失败\n
 
 		* @note
 
@@ -59,142 +59,142 @@ namespace YADB
 		*/
 		bool Connect( const _DB_CONN_SETTING_& DBSetting, std::string& Error );
 		/**
-	    * @brief
-	    鍏抽棴杩炴帴鍑芥暟銆�
+		* @brief
+		关闭连接函数。
 
-	    * @param  鏃燶n
+		* @param  无\n
 
-	    * @return  鏃燶n
+		* @return  无\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		void Close();
 		/**
-	    * @brief
-	    娴嬭瘯杩炴帴鍑芥暟銆�
+		* @brief
+		测试连接函数。
 
-	    * @param [out] std::string& Error 閿欒�淇℃伅\n
+		* @param [out] std::string& Error 错误信息\n
 
-	    * @return 杩斿洖娴嬭瘯杩炴帴鏄�惁鎴愬姛
-	    * @return  0  杩炴帴娴嬭瘯鎴愬姛\n
-	    * @return  !=0  杩炴帴娴嬭瘯澶辫触\n
+		* @return 返回测试连接是否成功
+		* @return  0  连接测试成功\n
+		* @return  !=0  连接测试失败\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		int ConnctionTest( std::string& Error );
 		/**
-	    * @brief
-	    璁剧疆鑷�姩鎻愪氦鐨勫嚱鏁般€�
+		* @brief
+		设置自动提交的函数。
 
-	    * @param [in] bool Mode 鏄�惁鏄�惁鑷�姩鎻愪氦\n
-	    * @param [out] std::string& Error 閿欒�淇℃伅\n
+		* @param [in] bool Mode 是否是否自动提交\n
+		* @param [out] std::string& Error 错误信息\n
 
-	    * @return 杩斿洖璁剧疆鑷�姩鎻愪氦鏄�惁鎴愬姛
-	    * @return  0  鎴愬姛\n
-	    * @return  !=0  澶辫触\n
+		* @return 返回设置自动提交是否成功
+		* @return  0  成功\n
+		* @return  !=0  失败\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		int AutoCommit( bool Mode, std::string& Error );
 		/**
-	    * @brief
-	    鎻愪氦鍑芥暟銆�
+		* @brief
+		提交函数。
 
-	    * @param [out] std::string& Error 閿欒�淇℃伅\n
+		* @param [out] std::string& Error 错误信息\n
 
-	    * @return 杩斿洖鎻愪氦鏄�惁鎴愬姛
-	    * @return  0  鎴愬姛\n
-	    * @return  !=0  澶辫触\n
+		* @return 返回提交是否成功
+		* @return  0  成功\n
+		* @return  !=0  失败\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		int Commit( std::string& Error  );
 		/**
-	    * @brief
-	    鍥炴粴鍑芥暟銆�
+		* @brief
+		回滚函数。
 
-	    * @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param [out] std::string& Error  错误信息\n
 
-	    * @return 杩斿洖鍥炴粴鏄�惁鎴愬姛
-	    * @return  0  鎴愬姛\n
-	    * @return  !=0  澶辫触\n
+		* @return 返回回滚是否成功
+		* @return  0  成功\n
+		* @return  !=0  失败\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		int RollBack( std::string& Error );
 		/**
-	    * @brief
-	    鎵ц�SQL璇�彞杩斿洖缁撴灉闆嗗嚱鏁般€�
+		* @brief
+		执行SQL语句返回结果集函数。
 
-	    * @param [in] const char *szSql  SQL璇�彞\n
-	    * @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param [in] const char *szSql  SQL语句\n
+		* @param [out] std::string& Error  错误信息\n
 
-	    * @return 杩斿洖缁撴灉闆�
-	    * @return  0  澶辫触\n
-	    * @return  !=0  鎴愬姛\n
+		* @return 返回结果集
+		* @return  0  失败\n
+		* @return  !=0  成功\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		CDBResultSet* ExecuteQuery( const char *szSql, std::string& Error );
 		/**
-	    * @brief
-	    鎵ц�SQL璇�彞杩斿洖mysql鍘熷�缁撴灉闆嗗嚱鏁般€�
+		* @brief
+		执行SQL语句返回mysql原始结果集函数。
 
-	    * @param [in] const char *szSql  SQL璇�彞\n
-	    * @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param [in] const char *szSql  SQL语句\n
+		* @param [out] std::string& Error  错误信息\n
 
-	    * @return 杩斿洖鐨刴ysql鍘熷�缁撴灉闆�
-	    * @return  ==0  澶辫触\n
-	    * @return  !=0  鎴愬姛\n
+		* @return 返回的mysql原始结果集
+		* @return  ==0  失败\n
+		* @return  !=0  成功\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		MYSQL_RES* Query( const char *szSql, std::string& Error );
 		/**
 		* @brief
-		鎵ц�SQL璇�彞鍑芥暟銆�
+		执行SQL语句函数。
 
-		* @param [in] const char *szSql  SQL璇�彞\n
-		* @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param [in] const char *szSql  SQL语句\n
+		* @param [out] std::string& Error  错误信息\n
 
-		* @return 杩斿洖褰卞搷鍒扮殑璁板綍鏁伴噺
-		* @return  -1  澶辫触\n
-		* @return  >=0  鎴愬姛\n
+		* @return 返回影响到的记录数量
+		* @return  -1  失败\n
+		* @return  >=0  成功\n
 
 		* @note
 
@@ -205,84 +205,65 @@ namespace YADB
 		*/
 		my_ulonglong ExecuteSql( const char *szSql, std::string& Error );
 		/**
-	    * @brief
-	    鎵ц�SQL璇�彞鍑芥暟銆�
+		* @brief
+		执行SQL语句函数。
 
-	    * @param [in] const char *szSql  SQL璇�彞\n
-	    * @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param [in] const char *szSql  SQL语句\n
+		* @param [out] std::string& Error  错误信息\n
 
-	    * @return 杩斿洖褰卞搷鍒扮殑璁板綍鏁伴噺
-	    * @return  -1  澶辫触\n
-	    * @return  >=0  鎴愬姛\n
+		* @return 返回影响到的记录数量
+		* @return  -1  失败\n
+		* @return  >=0  成功\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		my_ulonglong ExecuteRealSql( const char *szSql, std::string& Error );
-		/**
-		* @brief
-		鎵ц�SQL璇�彞骞惰幏寰楄嚜鍔ㄧ敓鎴愮殑ID鍑芥暟銆�
-
-		* @param [in] const char *szSql  SQL璇�彞\n
-		* @param [out] std::string& Error  閿欒�淇℃伅\n
-
-		* @return 杩斿洖鑷�姩鐢熸垚鐨処D
-		* @return  <1  澶辫触\n
-		* @return  >=1  鎴愬姛\n
-
-		* @note
-
-		* @warning
-
-		* @bug
-
-		*/
-		my_ulonglong ExecuteSqlID( const char *szSql, std::string& Error );
 		/**
-	    * @brief
-	    鑾峰緱鏈€鍚庝竴娆￠敊璇�俊鎭�嚱鏁般€�
+		* @brief
+		获得最后一次错误信息函数。
 
-	    * @param 鏃燶n
+		* @param 无\n
 
-	    * @return 杩斿洖鏈€鍚庝竴娆￠敊璇�
+		* @return 返回最后一次错误
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		const char* GetLastError();
 		/**
-	    * @brief
-	    鑾峰緱鏈€鍚庝竴娆℃彃鍏ョ殑ID鍑芥暟銆�
+		* @brief
+		获得最后一次插入的ID函数。
 
-	    * @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param [out] std::string& Error  错误信息\n
 
-	    * @return 杩斿洖鏈€鍚庝竴娆℃彃鍏ョ殑ID
-	    * @return  -1  澶辫触\n
-	    * @return  >=0  鎴愬姛\n
+		* @return 返回最后一次插入的ID
+		* @return  -1  失败\n
+		* @return  >=0  成功\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		my_ulonglong GetLastInsertID( std::string& Error );
 		/**
 		* @brief
-		鑾峰緱鏄�惁鏄�复鏃剁殑杩炴帴鍑芥暟銆�
+		获得是否是临时的连接函数。
 
-		* @param 鏃燶n
+		* @param 无\n
 
-		* @return 杩斿洖鏄�惁鏄�复鏃剁殑
+		* @return 返回是否是临时的
 
 		* @note
 
@@ -293,59 +274,79 @@ namespace YADB
 		*/
 		bool IsTemp();
 		/**
-	    * @brief
-	    鍑嗗�stmt鍑芥暟銆�
+		* @brief
+		准备stmt函数。
 
-	    * @param const char *szSql 棰勫�鐞哠QL璇�彞\n
-	    * @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param const char *szSql 预处理SQL语句\n
+		* @param [out] std::string& Error  错误信息\n
 
-	    * @return 杩斿洖鍑嗗�stmt鏄�惁鎴愬姛
-	    * @return  false  澶辫触\n
-	    * @return  true  鎴愬姛\n
+		* @return 返回准备stmt是否成功
+		* @return  false  失败\n
+		* @return  true  成功\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		bool Preparestmt( const char *szSql, std::string& Error );
 		/**
-	    * @brief
-	    鎵ц�stmt鍑芥暟銆�
+		* @brief
+		执行stmt函数。
 
-	    * @param [in] MYSQL_BIND *stBinds  瑕佹墽琛岀殑BIND\n
-	    * @param [in] uint64_t *piId  鎵ц�鍚庤幏寰楃殑ID\n
-	    * @param [out] std::string& Error  閿欒�淇℃伅\n
+		* @param [in] MYSQL_BIND *stBinds  要执行的BIND\n
+		* @param [in] uint64_t *piId  执行后获得的ID\n
+		* @param [out] std::string& Error  错误信息\n
 
-	    * @return 杩斿洖鎵ц�stmt鎴愬姛杩樻槸澶辫触
-	    * @return  false  澶辫触\n
-	    * @return  true  鎴愬姛\n
+		* @return 返回执行stmt成功还是失败
+		* @return  false  失败\n
+		* @return  true  成功\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		bool stmtExcute( MYSQL_BIND *stBinds, uint64_t *piId, std::string& Error );
 		/**
-	    * @brief
-	    鍏抽棴stmt鍑芥暟銆�
+		* @brief
+		关闭stmt函数。
 
-	    * @param 鏃燶n
+		* @param 无\n
 
-	    * @return 鏃燶n
+		* @return 无\n
 
-	    * @note
+		* @note
 
-	    * @warning
+		* @warning
 
-	    * @bug
+		* @bug
 
-	    */
+		*/
 		void stmtClose();
+		/**
+		* @brief
+		执行SQL语句并获得自动生成的ID函数。
+
+		* @param [in] const char *szSql  SQL语句\n
+		* @param [out] std::string& Error  错误信息\n
+
+		* @return 返回自动生成的ID
+		* @return  <1  失败\n
+		* @return  >=1  成功\n
+
+		* @note
+
+		* @warning
+
+		* @bug
+
+		*/
+		my_ulonglong ExecuteSqlID( const char *szSql, std::string& Error );
 	};
 }
+