ADO简单封装（MFC）

简单封装了一下，不是很严谨。

 /************************************************************************/
 /* INSTRUCTION: 封装ADO数据库相关操作
    DETAILS: 只能在MFC下使用，因此使用了MFC的字符串类
             尝试进行了深度封装，但是很多选项(如存储过程)被屏蔽了，适合小型项目使用。
    NOTE: ADO数据库访问并不是线程安全的，多个线程公用一个Connection需要线程同步，推荐方法
    是每个线程用一个单独的Connection，因此这里没有写成单例模式
 */
 /************************************************************************/
 #pragma once

 #include <comdef.h>
 #include <list>
 #include <set>
 #include <string>
 #include <boost\lexical_cast.hpp>

 #import "c:\program files\common files\system\ado\msado15.dll" no_namespace rename("EOF","adoEOF")

 class AdoRecordReader;
 class CAdoController
 {
 public:

     CAdoController(void)
     {
         AfxOleInit();
     }
     ~CAdoController();

     enum DatabaseProviderEnum
     {
         Access2000,
         ODBC,
         Oracle,
         SqlServer,
     };

     bool init();
     //连接数据库
     bool Connect(const std::string connectstring);
     bool Connect(DatabaseProviderEnum database,std::string dataSource,
         std::string ip,std::string username,std::string psw);

     //是否连接成功
     bool IsConnected()const
     {
         return (bool)m_pConnection->State;
     }

     //非SELECT命令，返回影响的行数
     int ExecuteNonQuery(const std::string&  command);

     //SELECT命令，返回封装的_RecordSetPtr
     AdoRecordReader ExecuteReader(const std::string& command);

     //TODO：存储过程，待实现
     //_RecordsetPtr ExecuteStoreProceduce(const std::string& storeProceduceName);

 private:
     std::string connectStringBuilder( DatabaseProviderEnum database,
          std::string &ip, std::string dataSource,
         std::string username, std::string psw );

     _ConnectionPtr m_pConnection;
     _CommandPtr m_pCommand;
     _RecordsetPtr m_pRecordset;
 };

 /*
  *    _RecordSetPtr相关函数封装，只读实现，不考虑ADO离线层
  */
 class AdoRecordReader
 {
 public:
     explicit AdoRecordReader(_RecordsetPtr ptr):
         m_recordSetPtr(ptr)
     {

     }
     //使其引用计数+1
     AdoRecordReader(const AdoRecordReader& lhs)
     {
         m_recordSetPtr=lhs.m_recordSetPtr->Clone(adLockOptimistic);
     }

     //减少引用计数
     ~AdoRecordReader()
     {
         if (m_recordSetPtr->State)
         {
             m_recordSetPtr->Close();
             m_recordSetPtr.Release();
         }
     }

     //移动至下一条记录
     bool MoveNext()
     {
         HRESULT hr;
         hr=m_recordSetPtr->MoveNext();

         if (!SUCCEEDED(hr))
         {
             return false;
         }
         if (m_recordSetPtr->adoEOF)
         {
             return false;
         }
         return true;
     }
     //移动到第一条记录
     void MoveFirst()
     {
         m_recordSetPtr->MoveFirst();
     }
     //重载下标访问操作符（索引和列名）,注意这里下标访问也是只读的
     _variant_t operator[](const size_t index)const;
     _variant_t operator[](const std::string key)const;

     //强类型get函数，使用模板来进行强制类型转换
     template<typename T>
     T get(const size_t index)const
     {
         return boost::lexical_cast<T>(this->operator[](index));
     }
     template<typename T>
     T get(const std::string key)const
     {
         return boost::lexical_cast<T>(this->operator[](key));
     }

     //字符串特化
     template<>
     std::string get<std::string>(const size_t index)const
     {
         return std::string((char *)(_bstr_t)(this->operator[](index)));
     }

     template<>
     std::string get<std::string>(const std::string key)const
     {
         return std::string((char *)(_bstr_t)(this->operator[](key)));
     }

     //行数
     int RecordCount()
     {
         return m_recordSetPtr->RecordCount;
     }
     //列数
     int FieldCount()
     {
         return m_recordSetPtr->Fields->Count;
     }
 private:
     _RecordsetPtr m_recordSetPtr;
 };

 #include "AdoController.h"
 #include <iostream>
 #include <stdexcept>
 #include <boost\algorithm\string.hpp>

 CAdoController::~CAdoController(void)
 {
     if (m_pConnection->State)
     {
         m_pConnection->Close();
     }
     m_pCommand.Release();
     m_pRecordset.Release();
     m_pConnection.Release();
 }

 bool CAdoController::init()
 {
     HRESULT hr;

     hr=m_pConnection.CreateInstance("ADODB.Connection");
     if (!SUCCEEDED(hr))
     {
         return false;
     }

     hr=m_pCommand.CreateInstance("ADODB.Command");
     if (!SUCCEEDED(hr))
     {
         return false;
     }

     hr=m_pRecordset.CreateInstance("ADODB.Recordset");
     if (!SUCCEEDED(hr))
     {
         return false;
     }

     return true;
 }

 bool CAdoController::Connect( DatabaseProviderEnum database, std::string dataSource,
                              std::string ip,std::string username,std::string psw)
 {
     if (m_pConnection->State)
     {
         m_pConnection->Close();
     }
     std::string connectstring = connectStringBuilder(database, ip, dataSource, username, psw);
     return Connect(connectstring);
 }

 bool CAdoController::Connect( const std::string connectstring )
 {
     HRESULT hr;
     try
     {
         hr=m_pConnection->Open(_bstr_t(connectstring.c_str()),"","",adModeUnknown);
         if (!SUCCEEDED(hr))
         {
             throw std::exception();
         }
         return true;
     }
     catch(_com_error e)
     {
         std::cerr<<"连接数据库失败！"<<std::endl
             <<e.Description()<<std::endl;
         return false;
     }
 }

 std::string CAdoController::connectStringBuilder( DatabaseProviderEnum database,
                                                  std::string &ip, std::string dataSource,
                                                  std::string username, std::string psw )
 {
     std::string connectstring;
     switch (database)
     {
     case CAdoController::Access2000:
         connectstring+="Provider=Microsoft.Jet.OLEDB.4.0;DataSource=";
         if (ip.length()!=)
         {
             connectstring+="\\\\"+ip+"\\"+dataSource+";";
         }
         else
         {
             connectstring+=dataSource+";";
         }
         connectstring+=username+";";
         connectstring+=psw+";";
         break;
     case CAdoController::ODBC:
         //FIXIT: 远程连接字符串待添加
         connectstring+="Provider=MADASQL;DSN="+dataSource+";UID="+
             username+";PWD="+psw+";";
         break;
     case CAdoController::Oracle:
         //FIXIT: 远程连接字符串待添加
         connectstring+="Provider=MSDAORA;DataSource="+dataSource+";User ID="+
             username+";Password="+psw+";";
         break;
     case CAdoController::SqlServer:
         if (username!="")
         {
             connectstring+="Provider=SQLOLEDB;DataSource="+ip+";Initial Catalog="+
                 dataSource+";UserID="+username+";Password="+psw+";";
         }
         else
         {
             connectstring+="Provider=SQLOLEDB;DataSource=.;Initial Catalog="+
                 dataSource+";Integrated Security=SSPI;";
         }
         break;
     default:
         break;
     }
     return connectstring;
 }

 int CAdoController::ExecuteNonQuery( const std::string& command )
 {
     if(boost::istarts_with(command,"select"))
     {
         throw std::exception("SELECT command queried, you should use ExecuteReader Instead!");
         return ;
     }
     if (!m_pConnection->State)
     {
         throw std::exception("数据库连接尚未打开");
         return ;
     }
     _variant_t effectLineCount=;
     m_pConnection->Execute(_bstr_t(command.c_str()),&effectLineCount,adCmdText);

     return (int)effectLineCount;
 }

 //执行查询命令，注意这里会抛出异常
 AdoRecordReader CAdoController::ExecuteReader( const std::string& command )
 {
     if (!boost::istarts_with(command,"select"))
     {
         throw std::exception("Non SELECT command executed, you should user ExecuteNonQuery instead");
     }
     if (!m_pConnection->State)
     {
         std::cerr<<"数据库连接尚未打开"<<std::endl;
         throw std::exception("数据库未打开");
     }

     _variant_t conn=_variant_t((IDispatch *)m_pConnection,true);

     try
     {
         if (m_pRecordset->State)
         {
             m_pRecordset->Close();
         }
         m_pRecordset->Open(_variant_t(command.c_str()),conn,adOpenStatic,
             adLockOptimistic,adCmdText);
         return AdoRecordReader(m_pRecordset);
     }
     catch(_com_error e)
     {
         std::cerr<<e.Description()<<std::endl;
         throw std::exception("查询出现错误");
     }
 }

 _variant_t AdoRecordReader::operator[]( const size_t index ) const
 {
     try
     {
         return m_recordSetPtr->GetCollect(_variant_t((long)index));
     }
     catch(_com_error e)
     {
         std::cerr<<e.Description()<<std::endl;
         return NULL;
     }
 }

 _variant_t AdoRecordReader::operator[]( const std::string key ) const
 {
     try
     {
         return m_recordSetPtr->GetCollect(_variant_t(key.c_str()));
     }
     catch(_com_error e)
     {
         std::cerr<<e.Description()<<std::endl;
         return NULL;
     }
 }