ADO简单封装（MFC）

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

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

#include <comdef.h>
#include <list>
#include <set>
#include <string>
#include <boostlexical_cast.hpp>

#import "c:program filescommon filessystemadomsado15.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 <boostalgorithmstring.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()!=0)
        {
            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 0;
    }
    if (!m_pConnection->State)
    {
        throw std::exception("数据库连接尚未打开");
        return 0;
    }
    _variant_t effectLineCount=0;
    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;
    }
}