clsdbtools.cpp

该模块完成的主要功能是让用户通过调用提供的打开数据库、执行SQL语句、关闭数据库三个主要的函数

#include "clsdbtools.h" 

int ClsDbTools::m_colNum = 0;
char **ClsDbTools::m_colName = NULL;
int ClsDbTools::m_nRecord = 0;

#ifdef _FORLINUX_
GList *ClsDbTools::m_recordList = NULL;
#else
vector <record*> ClsDbTools::m_datavector;
vector <int> :: size_type ClsDbTools::m_ivector;
#endif

sqlite3 *ClsDbTools::m_db = NULL;
bool ClsDbTools::m_execState = TRUE;

ClsDbTools::ClsDbTools()
{
	m_colName = NULL;
	//m_rec = NULL;
	m_colNum = 0;
	m_nRecord = 0;
	m_iWaitCount = 0;
	m_zErrMsg = NULL;
	
#ifdef _FORLINUX_
	
#else
	/*load dynamic library for windows */
	sqlitelib = LoadLibrary("sqlite3.dll");
#endif
}

ClsDbTools::~ClsDbTools()
{
	
	cleanCallback();
	
#ifdef _FORLINUX_
	
#else
	/*free dynamic library for windows*/
	FreeLibrary(sqlitelib);
#endif
	
}

/******************************************************************
* function name : ClsDbTools::OpenDatabase(const char *dbpath)
* function description : open database.
* finished date:  2004-8-18
* Author  : FanZiqiang
* parameter:   dbpath--database name and path
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
******************************************************************/
int ClsDbTools::OpenDatabase(const char *dbpath)
{
	int iRet = DATABASE_SUCCESS;
	
	/*determine whether the database can be accessed*/
	iRet = _access(dbpath, 0);			
	
#ifdef _FORLINUX_

	if(iRet != DATABASE_SUCCESS){
		/*sqlite3_open function to open a new sqlite3 database.  */
		iRet = sqlite3_open(dbpath, &m_db);
		if( 0 == m_db ){
			iRet = DBT_OPEN_DB_FAILED;
		}
	}else{
		m_db = sqlite3_open(dbpath, &m_db);
		if( 0 == m_db ){
			iRet = DBT_OPEN_DB_FAILED;
		}
	}
	
#else	

	/*sqlite3_open function to open a new sqlite3 database.  */
	typedef int (*sqlopen)(const char *, sqlite3 **);
	sqlopen sqliteOpen;
	
	sqliteOpen = (sqlopen)GetProcAddress(sqlitelib,"sqlite3_open");
	if(sqliteOpen != NULL){
		if(iRet != 0){
			iRet = sqliteOpen(dbpath, &m_db);
			if( 0 == m_db ){   
				iRet = DBT_OPEN_DB_FAILED;
			}
		}else{
			iRet = sqliteOpen(dbpath, &m_db);
			if( 0 == m_db ){   
				iRet = DBT_OPEN_DB_FAILED;
			}
		}
	}else{
		iRet = DBT_OPEN_DLL3_FAILED;
	}
	
#endif
	
	return iRet;	
}

/**********************************************************************************************
* function name : ClsDbTools::callback(void *NotUsed, int argc, char **argv, char **azColName)
* function description : return select info.
* finished date:  2004-8-18
* Author  : FanZiqiang
* parameter:   NotUsed
* 			    argc--return field num
* 			    argv--return field info of one row
* 			    azColName--return field name
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
**********************************************************************************************/
int ClsDbTools::callback(void *NotUsed, int argc, char **argv, char **azColName)
{
	
	int iRet = DATABASE_SUCCESS;
	
	/*storage field number*/
	m_colNum = argc;
	
	/*storage field name*/
	if (m_nRecord == 0){
		m_colName = (char**)_tmalloc(m_colNum * sizeof(char*));
		for(int i = 0; i < m_colNum; i++){
			m_colName[i] = (char*)_tmalloc(_tcslen(azColName[i]) + 2);
			_tcscpy(m_colName[i], azColName[i]);
		}
	}
	
	/*storage record number*/
	m_nRecord++;
	
	/*storage record value*/
	record *rectemp = (record*)_tmalloc(sizeof(record));
	rectemp->pRec = (char**)_tmalloc(sizeof(char*) * m_colNum);
	for(int i = 0; i < m_colNum; i++){
		if (NULL == argv[i]){
			rectemp->pRec[i] = (char*)_tmalloc(2);
			_tcscpy(rectemp->pRec[i], "");
		}
		else{
			rectemp->pRec[i] = (char*)_tmalloc(_tcslen(argv[i]) + 2);
			_tcscpy(rectemp->pRec[i], argv[i]);
			
		}
	}
	
#ifdef _FORLINUX_
	/*storage all records value*/
	m_recordList = g_list_append(m_recordList, rectemp);
	
#else
    /*storage all records value*/
	m_datavector.push_back(rectemp);
	
#endif
	
	return iRet;
}


/******************************************************************
* function name : ClsDbTools::Execute(char *strSql)
* function description : execute query.
* finished date:  2004-8-18
* Author  : FanZiqiang
* parameter:   strSql--SQL query string
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
******************************************************************/
int ClsDbTools::Execute(const char *strSql)
{
	int iRet = DATABASE_SUCCESS;
	
	if( m_db == 0 ){
		
		iRet = DBT_DATABASE_IS_CLOSE;
	}
	else{
		if( TRUE == m_execState ){
			m_execState = FALSE;
			if( DATABASE_SUCCESS == cleanCallback() ){
				
#ifdef _FORLINUX_
				/*sqlite3_exec function to executes one or more statements of SQL*/
				m_rc = sqlite3_exec(m_db, strSql, callback, 0, &m_zErrMsg);
				
#else
				/*sqlite3_exec function to executes one or more statements of SQL*/
				typedef int (*sqlexec)(sqlite3*,                      /* An open database */
					const char *sql,           /* SQL to be executed */
					sqlite3_callback,            /* Callback function */
					void *,                        /* 1st argument to callback function */
					char **errmsg);
				sqlexec sqliteExec;
				
				sqliteExec = (sqlexec)GetProcAddress(sqlitelib,"sqlite3_exec");
				if( sqliteExec != NULL ){
					m_rc = sqliteExec(m_db, strSql, callback, 0, &m_zErrMsg);
				}else{
					iRet = DBT_OPEN_DLL_FAILED;
				}
				
#endif
				
				if((m_rc == SQLITE_OK)||(m_rc == SQLITE_EMPTY)){
					iRet = DATABASE_SUCCESS;
					
				}
				else{
					switch (m_rc){
					case 1:	iRet = DBT_SQLITE_ERROR;
						break;
					case 2:	iRet = DBT_SQLITE_INTERNAL;
						break;
					case 3:	iRet = DBT_SQLITE_PERM;
						break;
					case 4:	iRet = DBT_SQLITE_ABORT;
						break;
					case 5:	iRet = DBT_SQLITE_BUSY;
						break;
					case 6:	iRet = DBT_SQLITE_LOCKED;
						break;
					case 7:	iRet = DBT_SQLITE_NOMEM;
						break;
					case 13:	iRet = DBT_SQLITE_FULL;
						break;
					case 14:	iRet = DBT_SQLITE_CANTOPEN;
						break;
					case 15:	iRet = DBT_SQLITE_PROTOCOL;
						break;
					case 20:	iRet = DBT_SQLITE_MISMATCH;
						break;
					default:
						iRet = DBT_EXECUTE_FAILED;
						
					}
				}
			}	
			else{
				iRet = DBT_CLEAN_RECORD_FAILED;
			}
			m_execState = TRUE;
			m_iWaitCount = 0;
		}
		else{
			if (m_iWaitCount < SQL_MAX_WAIT_TIMES){
				m_iWaitCount++;
				
				/*wait one minute*/
#ifdef _FORLINUX_
				_sleep(1);
#else
				_wsleep(1000);
#endif
				
				iRet = Execute(strSql);
				
			}
			else{
				iRet = DBT_SQLITE_BUSY;
			}
		}
	}
	
	return iRet;
	
}

/*****************************************************************
* function name : ClsDbTools::cleanCallback()
* function description : clean callback.
* finished date:  2004-8-18
* Author  : FanZiqiang
* parameter:  
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
*****************************************************************/
int ClsDbTools::cleanCallback()
{
	int iRet = DATABASE_SUCCESS;
	
	int iCol = 0;
	unsigned int iRow = 0;
	record *rectemp = NULL;
	if (m_colName != NULL){
		for(iCol = 0; iCol < m_colNum; iCol++){
			_tfree(m_colName[iCol]);
		}
		_tfree(m_colName);
		
#ifdef _FORLINUX_
		
		for (iRow = 0; iRow < g_list_length(m_recordList); iRow++){
			rectemp = (record *)g_list_nth_data(m_recordList, iRow);
			for(iCol = 0; iCol < m_colNum; iCol++){
				_tfree(rectemp->pRec[iCol]);
				rectemp->pRec[iCol] = NULL;
			}
			_tfree(rectemp->pRec);
			rectemp->pRec = NULL;
			_tfree(rectemp);
		}
		g_list_free(m_recordList);
		m_recordList = NULL;
		
		
#else
		m_ivector=m_datavector.size( );
		
		for (iRow = 0; iRow < m_ivector; iRow++){
			rectemp = m_datavector[iRow];
			for(iCol = 0; iCol < m_colNum; iCol++){
				_tfree(rectemp->pRec[iCol]);
				rectemp->pRec[iCol] = NULL;
			}
			_tfree(rectemp->pRec);
			rectemp->pRec = NULL;
			_tfree(rectemp);
		}
		m_datavector.clear( );
		
#endif
		
	}
	m_colName = NULL;
	//m_rec = NULL;
	m_colNum = 0;
	m_nRecord = 0;
	
	return iRet;
}

/*****************************************************************
* function name : ClsDbTools::CloseDatabase()
* function description : close database.
* finished date:  2004-8-18
* Author  : FanZiqiang
* parameter: 
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
******************************************************************/
void ClsDbTools::CloseDatabase()
{
	if(m_db != 0){
		
#ifdef _FORLINUX_
		/*sqlite3_close function to close the database*/
		sqlite3_close(m_db);
#else
		/*sqlite3_close function to close the database*/
		typedef void (*sqlclose)(sqlite3 *);
		sqlclose sqliteClose;
		
		sqliteClose = (sqlclose)GetProcAddress(sqlitelib,"sqlite3_close");
		sqliteClose(m_db);
		
#endif
		
		m_db = NULL;
	}
	
}


/***********************************************************************
* function name : ClsDbTools::replaceChar(char *result, char *repResult)
* function description :replace char to string in one string
* finished date:  2004.8.24
* Author  : FanZiqiang
* parameter:   result--one string
* 			    repResult--the string is changed
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
************************************************************************/
int ClsDbTools::replaceChar(const char *result, char *repResult)
{
	
	char *pter = NULL;
	char cold ;
	char cnew[2];
	int start, end, rlen;
	char tempR2[2048], tempR1[2048];
	int iRet = DATABASE_SUCCESS;
	
	cold ='\'';
	_tcscpy(cnew, "\'\'");
	_tcscpy(tempR2, "");
	_tcscpy(tempR1, "");
	if (NULL == result){
		_tcscpy(repResult, "");
	}
	else{
		pter = _tcschr(result, cold);
		if(pter){
			rlen = _tcslen(result);
			_tcscpy(tempR2, "");
			for (start = end = 0; end < rlen; end++){
				if (result[end] == cold){
					strcpStarttoEnd(tempR1, result, start, end);
					_stprintf(tempR2, "%s%s%s",tempR2, tempR1, cnew);
					start = end + 1;
				}
			}
			strcpStarttoEnd(tempR1, result, start, rlen);
			_tcscat(tempR2, tempR1);
			_tcscpy(repResult, tempR2);
		}else{
			_tcscpy(repResult, result);
		}
	}
	
	return iRet;
	
}


/************************************************************************************************
* function name : ClsDbTools::strcpStarttoEnd(char *dest, const char *result, int start, int end)
* function description :copy string from start to end.
* finished date:  2004.8.26
* Author  : FanZiqiang
* parameter:   
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
************************************************************************************************/
int ClsDbTools::strcpStarttoEnd(char *dest, const char *result, int start, int end)
{
	
	int iRet = DATABASE_SUCCESS;
	
	int lenth, i;
	lenth=end-start;
	for (i=0;i<lenth;i++)
		dest[i]=result[start+i];
	dest[lenth]='\0';
	
	return iRet;
}


/*****************************************************************
* function name : ClsDbTools::getErrorMsg(char *sError)
* function description :get the error message of the last action
* finished date:  2004-8-18
* Author  : FanZiqiang
* parameter:    sError -- pointer to the error message
* retrun value:  SAN_SUCCESS--action succeed；other--action failed
* restrained condition:  NONE
* side effect:  Describe NONE
******************************************************************/
int   ClsDbTools::getErrorMsg(char *sError)
{
	
	int iRet = DATABASE_SUCCESS;
	
	if (sError != NULL){
		iRet = DATABASE_SUCCESS;
	}
	else{
		iRet = DBT_ERROR_POINTER_NULL;
	}
	
	return iRet;
	
}