MySql C++调用库Connector/c++编译 和 接口封装【三】Connector/c++ 使用总结及封装

库使用需要几个文件：
　　1、include 文件夹   c/c++ /常规/附加包含目录
　　 Connector/c++ 的安装版里面的Include 文件夹。或者把  /driver以及/driver/nativeapi 里面的头文件拷贝到一个文件夹里面(注意nativeapi要改名为 cppconn)。
　　2、Connector/c++ 库文件 和 MySql库文件：
　　　　2.1、mysqlcppconn.dll   /debug,exe生成目录
　　　　2.2、mysqlcppconn.lib   链接器/输入/附加依赖项
　　　　2.3、libmysql.dll 　　　/debug　
　　3、boost库所在目录   c/c++/常规/附加包含目录

#ifndef __MYSQL_DATABASE_H
#define __MYSQL_DATABASE_H

#include "mysql_connection.h"
#include "mysql_driver.h"
#include "cppconn/prepared_statement.h"
#include "cppconn/statement.h"
#include <map>

typedef boost::scoped_ptr<sql::Connection> Connection;
typedef boost::scoped_ptr<sql::PreparedStatement> PreparedStatement;
typedef boost::scoped_ptr<sql::Statement> Statement;
typedef boost::shared_ptr<sql::ResultSet> ResultSet;
typedef sql::mysql::MySQL_Driver MySQL_Driver;

//mysql 错误类
class CMySqlError
{
//存储变量
protected:
int                        m_ErrorCode;
std::string                m_strErrorDescribe;

public:
//构造函数
CMySqlError();
//析构函数
~CMySqlError();
public:
//获取ErrorCode
int getErrorCode(){    return m_ErrorCode;    }
//错误描述
std::string GetErrorDestribe(){    return m_strErrorDescribe;    }

public:
//设置错误
void SetErrorInfo(sql::SQLException &e);
};

class CMySqlDataBase
{
//信息变量
protected:
CMySqlError                            m_MySqlError;            //当前错误信息
std::map<std::string, std::string>    m_ConnectProperties;    //连接信息

//状态变量
protected:
const unsigned int        m_dwTryConnectTimes;

//连接变量
protected:
Connection            m_DBConnect;
PreparedStatement    m_DBPrepareState;
ResultSet            m_DBRecordSet;

//函数定义
public:
//构造函数
CMySqlDataBase();
//析构函数
~CMySqlDataBase();

//管理接口
public:
//打开连接
bool OpenConnect();
//关闭记录
bool CloseRecordset();
//关闭连接
bool CloseConnect();
//重新连接(未实现)
bool TryConnectAgain();
//设置信息
bool SetConnectionInfo(const std::string &hostIp,unsigned short hostPort,const std::string &dataBaseName,const std::string &userName,const std::string &password);

//状态接口(未实现)
public:
//是否连接错误
bool IsConnectError();
//是否打开
bool IsRecordsetOpened();

//
public:
//准备prepareState
bool PreparedExcute(const std::string &szCommand);

bool setBigInt(unsigned int parameterIndex, const std::string& value);

bool setBlob(unsigned int parameterIndex, std::istream * blob);            //长文本字符串

bool setBoolean(unsigned int parameterIndex, bool value);

bool setDateTime(unsigned int parameterIndex, const std::string& value);

bool setDouble(unsigned int parameterIndex, double value);

bool setInt(unsigned int parameterIndex, int32_t value);

bool setUInt(unsigned int parameterIndex, uint32_t value);

bool setInt64(unsigned int parameterIndex, int64_t value);

bool setUInt64(unsigned int parameterIndex, uint64_t value);

bool setString(unsigned int parameterIndex, const std::string& value);

bool setNull(unsigned int parameterIndex, int sqlType);

//执行命令(存储过程）
bool ExecuteCommand(bool bRecordset);

//执行语句接口
public:
//执行查询(Select)
bool Query(const std::string &szCommand);
//执行语句(Insert,Update,Delete)
bool Execute(const std::string &szCommand);

//字段接口
/* next() must been used before getdata */
public:
//获取当前 Result set
const ResultSet &GetRecordSet();
//get Next Record set
bool GetNextResultSet();
//move resultset to the nth result in the set
bool NextFieldExist();
//获取参数
bool GetFieldValue(const std::string& columnLabel,bool &bValue);
//获取参数
bool GetFieldValue(const std::string& columnLabel,long double &dbValue);
//获取参数
bool GetFieldValue(const std::string& columnLabel,int32_t &nValue);
//获取参数
bool GetFieldValue(const std::string& columnLabel,uint32_t &uValue);
//获取参数
bool GetFieldValue(const std::string& columnLabel,int64_t &llValue);
//获取参数
bool GetFieldValue(const std::string& columnLabel,uint64_t &lluValue);
//获取参数
bool GetFieldValue(const std::string& columnLabel,char szBuffer[],uint32_t uSize);
//获取参数
bool GetFieldValue(const std::string& columnLabel,std::string &szValue);
//获取参数
//bool GetFieldValue(const std::string& columnLabel,SYSTEMTIME &systime);

//内部函数
private:
//设置错误
void SetErrorInfo(sql::SQLException &e);
};

#endif

#include "MySqlDataBase.h"
#include <sstream>

CMySqlError::CMySqlError()
{
}

CMySqlError::~CMySqlError()
{
}

void CMySqlError::SetErrorInfo(sql::SQLException &e)
{
m_ErrorCode = e.getErrorCode();
m_strErrorDescribe = e.what();

throw this;
}

CMySqlDataBase::CMySqlDataBase():m_DBConnect(NULL),m_DBPrepareState(NULL),m_DBRecordSet((sql::ResultSet*)NULL),m_dwTryConnectTimes(1)
{
}

CMySqlDataBase::~CMySqlDataBase()
{
try
{
CloseConnect();

m_DBRecordSet.reset((sql::ResultSet*)NULL);
m_DBPrepareState.reset(NULL);
m_DBConnect.reset(NULL);
}
catch(sql::SQLException &e) { SetErrorInfo(e);}
}

//设置错误
void CMySqlDataBase::SetErrorInfo(sql::SQLException &e)
{
m_MySqlError.SetErrorInfo(e);
}

//打开连接
bool CMySqlDataBase::OpenConnect()
{
//建立连接
try
{
sql::mysql::MySQL_Driver *driver = sql::mysql::get_mysql_driver_instance();

m_DBConnect.reset(driver->connect(m_ConnectProperties["hostName"],m_ConnectProperties["userName"],m_ConnectProperties["password"]));
m_DBConnect->setSchema(m_ConnectProperties["schema"]);
}
catch(sql::SQLException &e) { SetErrorInfo(e);}

return true;
}

//关闭记录
bool CMySqlDataBase::CloseRecordset()
{
try
{
if(m_DBPrepareState != NULL)
{
while(m_DBPrepareState->getMoreResults())
m_DBRecordSet.reset(m_DBPrepareState->getResultSet());

m_DBPrepareState.reset(NULL);
}

if(m_DBRecordSet != NULL)
m_DBRecordSet.reset((sql::ResultSet*)NULL);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//关闭连接
bool CMySqlDataBase::CloseConnect()
{
try
{
CloseRecordset();

//close connect
if(m_DBConnect != NULL)
{
m_DBConnect.reset(NULL);
}

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//设置信息
bool CMySqlDataBase::SetConnectionInfo(const std::string &hostIp,unsigned short hostPort,const std::string &dataBaseName,const std::string &userName,const std::string &password)
{
try
{
std::stringstream hostss;
hostss<<"tcp://"<<hostIp<<":"<<hostPort;

m_ConnectProperties["hostName"] = hostss.str();
m_ConnectProperties["userName"] = userName;
m_ConnectProperties["password"] = password;
m_ConnectProperties["schema"] = dataBaseName;

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//是否打开
bool CMySqlDataBase::IsRecordsetOpened()
{
if(m_DBRecordSet == NULL)
return false;

if(m_DBRecordSet->isClosed())
return false;

return true;
}

//准备prepareState
bool CMySqlDataBase::PreparedExcute(const std::string &szCommand)
{
if(szCommand.empty())    return false;

//close RecordSet;
CloseRecordset();
try
{
m_DBPrepareState.reset(m_DBConnect->prepareStatement(szCommand));
m_DBPrepareState->clearParameters();

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setBigInt(unsigned int parameterIndex, const std::string& value)
{
try
{
m_DBPrepareState->setBigInt(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setBlob(unsigned int parameterIndex, std::istream * value)            //长文本字符串
{
try
{
m_DBPrepareState->setBlob(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setBoolean(unsigned int parameterIndex, bool value)
{
try
{
m_DBPrepareState->setBoolean(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setDateTime(unsigned int parameterIndex, const std::string& value)
{
try
{
m_DBPrepareState->setDateTime(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setDouble(unsigned int parameterIndex, double value)
{
try
{
m_DBPrepareState->setDouble(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setInt(unsigned int parameterIndex, int32_t value)
{
try
{
m_DBPrepareState->setInt(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setUInt(unsigned int parameterIndex, uint32_t value)
{
try
{
m_DBPrepareState->setUInt(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setInt64(unsigned int parameterIndex, int64_t value)
{
try
{
m_DBPrepareState->setInt64(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setUInt64(unsigned int parameterIndex, uint64_t value)
{
try
{
m_DBPrepareState->setUInt64(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setString(unsigned int parameterIndex, const std::string& value)
{
try
{
m_DBPrepareState->setString(parameterIndex,value);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

bool CMySqlDataBase::setNull(unsigned int parameterIndex, int sqlType)
{
try
{
m_DBPrepareState->setNull(parameterIndex,sqlType);

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//执行命令(存储过程）
bool CMySqlDataBase::ExecuteCommand(bool bRecordset)
{
try
{
m_DBPrepareState->executeUpdate();

if(bRecordset)
m_DBRecordSet.reset(m_DBPrepareState->getResultSet());

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//执行查询(Select)
bool CMySqlDataBase::Query(const std::string &szCommand)
{
if(szCommand.empty())    return false;

//close RecordSet;
CloseRecordset();
try
{
m_DBPrepareState.reset(m_DBConnect->prepareStatement(szCommand));

m_DBPrepareState->executeUpdate();
m_DBRecordSet.reset(m_DBPrepareState->getResultSet());
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//执行语句(Insert,Update,Delete)
bool CMySqlDataBase::Execute(const std::string &szCommand)
{
if(szCommand.empty())    return false;

//close RecordSet;
CloseRecordset();
try
{
m_DBPrepareState.reset(m_DBConnect->prepareStatement(szCommand));
m_DBPrepareState->executeUpdate();

return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取当前 Result set
const ResultSet &CMySqlDataBase::GetRecordSet()
{
return m_DBRecordSet;
}

//get Next Record set
bool CMySqlDataBase::GetNextResultSet()
{
if(m_DBPrepareState == NULL)
return false;

if(m_DBPrepareState->getMoreResults())
{
m_DBRecordSet.reset(m_DBPrepareState->getResultSet());
return true;
}
return false;
}

//next
bool CMySqlDataBase::NextFieldExist()
{
if(m_DBRecordSet == NULL)
return false;

return m_DBRecordSet->next();
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,bool &bValue)
{
bValue = false;

if(!IsRecordsetOpened())
return false;

try
{
bValue =  m_DBRecordSet->getBoolean(columnLabel);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,long double &dbValue)
{
dbValue = 0.00;

if(!IsRecordsetOpened())
return false;

try
{
dbValue =  m_DBRecordSet->getDouble(columnLabel);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,int32_t &nValue)
{
nValue = 0;

if(!IsRecordsetOpened())
return false;

try
{
nValue =  m_DBRecordSet->getInt(columnLabel);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,uint32_t &uValue)
{
uValue = 0;

if(!IsRecordsetOpened())
return false;

try
{
uValue =  m_DBRecordSet->getUInt(columnLabel);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,int64_t &llValue)
{
llValue = 0;

if(!IsRecordsetOpened())
return false;

try
{
llValue =  m_DBRecordSet->getInt64(columnLabel);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,uint64_t &lluValue)
{
lluValue = 0;

if(!IsRecordsetOpened())
return false;

try
{
lluValue =  m_DBRecordSet->getUInt64(columnLabel);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,char szBuffer[],uint32_t uSize)
{
memset(szBuffer,0,uSize);

if(!IsRecordsetOpened())
return false;

try
{
sql::SQLString tempstr =  m_DBRecordSet->getString(columnLabel);
strncpy(szBuffer,tempstr.c_str(),uSize-1);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

//获取参数
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,std::string &szValue)
{
if(!IsRecordsetOpened())
return false;

try
{
szValue =  m_DBRecordSet->getString(columnLabel).asStdString();
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}

/*
//获取参数,SYSTEMTIME 可以通过 COleDateTime(const SYSTEMTIME& systimeSrc) 转换为 COleDateTime
bool CMySqlDataBase::GetFieldValue(const std::string& columnLabel,SYSTEMTIME &systime)
{
if(!IsRecordsetOpened())
return false;
memset(&systime,0,sizeof(SYSTEMTIME));
try
{
std::string timestr =  m_DBRecordSet->getString(columnLabel).asStdString();
sscanf(timestr.c_str(),"%04d-%02d-%02d %02d:%02d:%02d",&systime.wYear,&systime.wMonth,&systime.wDay,
&systime.wHour,&systime.wMinute,&systime.wSecond);
return true;
}
catch (sql::SQLException &e) { SetErrorInfo(e);}

return false;
}
*/

#pragma once

#define CRTDBG_MAP_ALLOC
#include <windows.h>
#include <tchar.h>
#include <crtdbg.h>
#include <stdlib.h>
#include <iostream>
#include <Psapi.h>
#pragma comment(lib,"psapi.lib")

#ifdef _DEBUG
#define malloc(s)           _malloc_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__)
#define calloc(c, s)        _calloc_dbg(c, s, _NORMAL_BLOCK, __FILE__, __LINE__)
#define realloc(p, s)       _realloc_dbg(p, s, _NORMAL_BLOCK, __FILE__, __LINE__)

#define new                    new(_NORMAL_BLOCK,__FILE__,__LINE__)
#endif

#define DEFAULT_OUT_TITLE    \
TEXT("缺页中断数  工作集(KB)  虚存(KB)  虚存峰值(KB)")
#define DEFAULT_OUTPUT_FORMAT    \
TEXT("  %u    %u    %u    %u  ")

// 字节单位转换，向0取整
#define B2KB(x)    ((x) >> 10)

///////////////////////////////////////////////////////////////////////////////////

void ConstructOutput()
{
PROCESS_MEMORY_COUNTERS pmc;
std::cout<<DEFAULT_OUT_TITLE<<std::endl;
if(!GetProcessMemoryInfo(GetCurrentProcess(),&pmc,sizeof(pmc)))return ;

char output[512] = {0};
_sntprintf(output,sizeof(output),DEFAULT_OUTPUT_FORMAT,
(pmc.PageFaultCount),B2KB(pmc.WorkingSetSize),B2KB(pmc.PagefileUsage),B2KB(pmc.PeakPagefileUsage));
std::cout<<output<<std::endl;
}

#include "MySqlDataBase.h"
#include "leakcheck.h"
using namespace std;

int main()
{
CMySqlDataBase mysqldb;
try{
mysqldb.SetConnectionInfo("127.0.0.1",3306,"test","root","123456");
mysqldb.OpenConnect();
ConstructOutput();　　　　　　　　　　//这个函数用来查看当前内存大小的
//for(int i = 0;i<100000;++i)
{
mysqldb.PreparedExcute("call testproc1(?)");
mysqldb.setInt(1,1001)
mysqldb.ExecuteCommand(true);
while(mysqldb.NextFieldExist())
{
int id;
std::string name;
mysqldb.GetFieldValue("id",id);
mysqldb.GetFieldValue("date",name);
cout<<"id:"<<id<<", name:"<<name<<endl;
}
}
ConstructOutput();
mysqldb.CloseConnect();
}
catch(CMySqlError *pSqlError)
{
cout<<pSqlError->getErrorCode()<<":"<<pSqlError->GetErrorDestribe()<<endl;
mysqldb.CloseConnect();
}

return 0;
}