现在的位置: 首页 > 综合 > 正文

半facade模式封装的ADO操作类（C++）

2013年07月06日 ⁄ 综合 ⁄ 共 37771字 ⁄ 字号 小 中 大 ⁄ 评论关闭

用VC操作ADO总是觉得很烦琐。于是把ADO的常用操作封装了一下，以此降低代码量。之所以叫它半facade模式，因为没有导出内部Connection和Recordset等对象，而直接把它做成了一个句柄类。所以客户程序无法与底层ADO对象通讯。如果需要精细操作ADO，可以加个GET方法导出一下m_pData的m_pCnn或者m_ppRec。
这个类有一点特别的是，有GetActiveRecordset / SetActiveRecordset方法，在打开Recordset后，当前打开的Recordset就成为ActiveRecordset，于是像GetFieldValue，MoveNext等操作就在这个Recordset上执行，OpenRecordset会返回当前成功打开的Recordset的标识。如果要操作其它的Recordset，调用一下SetActiveRecordset。
各个函数的参数枚举等说明在CPP文件中的函数注释中。
编译器：VC 2003
PS：使用前先CoInitialize(NULL);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   .h文件
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////
//
//    Ado封装类
//    时间：    2006-02-08
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////

#pragma once

#include <comutil.h>
#pragma comment(lib, "comsupp.lib")

struct ADODATA;

class CAdo
{
public:
    CAdo(void);
    virtual ~CAdo(void);

public:

    //返回连接字符串
    CString GetConnectString();
    //返回数据库服务器名称
    CString GetServerName(){return m_strServer;};
    //返回数据库名称
    CString GetDatabaseName(){return m_strDatabase;};
    //返回用户名
    CString GetUserName(){return m_strUser;};
    //返回密码
    CString GetPassword(){return m_strPass;};

    //返回Connection连接状态
    bool GetConnectOpen();
    //返回当前活动记录集打开状态
    bool GetRecordsetOpen();

    //返回/设置ConnectionTimeout
    int GetConnectionTimeout();
    void SetConnectionTimeout(int nTimeOut);
    //返回/设置CommandTimeout
    int GetCommandTimeout();
    void SetCommandTimeout(int nTimeOut);
    //返回/设置ConnectMode
    int GetConnectMode();
    void SetConnectMode(int nMode);
    //返回Version
    CString GetVersion();

    //设置当前的活动记录集
    void SetActiveRecordset(int nRecordset);
    //返回当前活动的记录集
    int GetActiveRecordset(){return m_nActiveRS;};

    //返回/设置记录位置
    int GetAbsolutePosition();
    void SetAbsolutePosition(int nPosition);
    //返回/设置页位置
    int GetAbsolutePage();
    void SetAbsolutePage(int nPage);
    //返回页数量
    int GetPageCount();
    //返回/设置页大小
    int GetPageSize();
    void SetPageSize(int nSize);
    //返回/设置CacheSize
    int GetCachSize();
    void SetCachSize(int nSize);
    //返回EditMode
    int GetEditMode();
    //返回Recordset状态
    int GetRecordStatus();

    //打开数据库连接
    int OpenConnect(int nProvider, CString strServer, CString strDatabase,
        CString strUser = "", CString strPass = "");
    int OpenConnect(CString strCnnStr);
    //关闭连接
    void CloseConnect();

    //开始事务
    int BeginTrans();
    //提交事务
    int CommitTrans();
    //取消事务
    int RollbackTrans();
    //执行非数据选取SQL
    int Execute(CString strSql, int* pAffected = NULL);
    //执行(sql server 2000)数据库脚本文件
    int ExecuteSqlFile(CString strFile);
    //打开记录集
    int OpenRecordset(CString strSql, int &nRecordset, int nCursorType = 2, int nLockType = 3);
    //关闭记录集
    void CloseRecordset(int nRecordset);

    //当前的活动记录集添加记录
    int Add();
    int Add(const _variant_t *pValues, int nNum);
    //当前的活动记录集删除当前游标所指的记录
    int Delete();
    //当前的活动记录集更新当前游标所指的记录
    int Update();
    //当前的活动记录集退出当前执行状态
    int Cancel();
    //当前的活动记录集退出当前Update操作
    int CancelUpdate();

    //返回当前的活动记录集记录总数
    int GetRecordCount();
    //返回当前的活动记录集BOF属性
    bool GetBOF();
    //返回当前的活动记录集EOF属性
    bool GetEOF();
    //当前的活动记录集移动至第一条记录
    int MoveFirst();
    //当前的活动记录集移动至最后一条记录
    int MoveLast();
    //当前的活动记录集移动至上一条记录
    int MovePrev();
    //当前的活动记录集移动至下一条记录
    int MoveNext();
    //当前的活动记录集移动至指定记录
    int Move(int nNum);

    //返回字段数目
    int GetFieldsCount();
    //返回字段名称
    CString GetFieldName(int nInd);
    //返回字段类型
    int GetFieldType(int nFieldInd);

    //返回字段数值
    _variant_t GetFieldValue(int nRecordInd, int nFieldInd);                    //记录由nRecordInd指定
    _variant_t GetFieldValue(int nFieldInd);                                    //当前记录
    _variant_t GetFieldValue(CString strField);                                    //当前记录
    //返回一条记录的数值
    int GetRecordValue(int nRecordInd, _variant_t *pValues, int nNum);            //记录由nRecordInd指定
    int GetRecordValue(_variant_t *pValues, int nNum);                            //当前记录
    //设置字段数值
    int SetFieldValue(int nRecordInd, int nFieldInd, const _variant_t &vValue);    //记录由nRecordInd指定
    int SetFieldValue(int nFieldInd, const _variant_t &vValue);                    //当前记录
    int SetFieldValue(CString strField, const _variant_t &vValue);                //当前记录
    //设置一条记录的数值
    int SetRecordValue(int nRecordInd, const _variant_t *pValues, int nNum);    //记录由nRecordInd指定
    int SetRecordValue(const _variant_t *pValues, int nNum);                    //当前记录

protected:
   
    //数据库对象结构
    ADODATA * m_pData;

    //数据库服务器
    CString m_strServer;
    //数据库名称
    CString m_strDatabase;
    //登录用户
    CString m_strUser;
    //密码
    CString m_strPass;
   
    //当前活动的记录集
    int m_nActiveRS;
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   .cpp文件
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include "./ado.h"

#include <deque>
using namespace std;

#import "C:/Program Files/Common Files/System/ADO/msado15.dll" /
    no_namespace rename("EOF", "EndOfFile")

struct ADODATA
{
    //数据库连接
    _ConnectionPtr m_pCnn;
    //记录集
    deque<_RecordsetPtr> m_ppRec;
};

CAdo::CAdo(void)
{
    m_pData = new ADODATA;

    if (m_pData != NULL)
    {
        m_pData->m_pCnn = NULL;
        m_pData->m_pCnn.CreateInstance(__uuidof(Connection));
    }
    m_nActiveRS = -1;
}

CAdo::~CAdo(void)
{
    if (m_pData != NULL)
    {
        try
        {
            //关闭所有记录集
            for (int nCount = 0; nCount < m_pData->m_ppRec.size(); nCount++)
            {
                if (m_pData->m_ppRec[nCount] != NULL)
                {
                    if (m_pData->m_ppRec[nCount]->State == adStateOpen)
                    {
                        if (!m_pData->m_ppRec[nCount]->BOF
                            && !m_pData->m_ppRec[nCount]->EndOfFile)
                        {
                            //对于AddNew或者修改了数据，而未保存的状态
                            if (m_pData->m_ppRec[nCount]->EditMode == adEditAdd
                                || m_pData->m_ppRec[nCount]->EditMode == adEditInProgress)
                            {
                                m_pData->m_ppRec[nCount]->CancelUpdate();
                            }
                        }
                        m_pData->m_ppRec[nCount]->Close();
                    }
                }
            }
            //关闭数据库连接
            if (m_pData->m_pCnn != NULL)
            {
                if (m_pData->m_pCnn->State != adStateClosed)
                {
                    m_pData->m_pCnn->Close();
                }
            }
        }
        catch(_com_error &e)
        {
            //SetSdkError(0, e.Error(), 0);
            return;
        }

        delete m_pData;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回连接字符串
//    参数：    none
//    返回值：                数据库连接字符串
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
CString CAdo::GetConnectString()
{
    if (m_pData->m_pCnn != NULL)
    {
        return m_pData->m_pCnn->GetConnectionString();
    }
    else
    {
        return "";
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回Connection连接状态
//    参数：    none
//    返回值：                数据库连接状态
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
bool CAdo::GetConnectOpen()
{
    if (m_pData->m_pCnn != NULL)
    {
        return (m_pData->m_pCnn->State != adStateClosed);
    }
    else
    {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回当前活动记录集打开状态
//    参数：    none
//    返回值：                记录集打开状态
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
bool CAdo::GetRecordsetOpen()
{
    if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
    {
        return m_pData->m_ppRec[m_nActiveRS]->State != adStateClosed;
    }
    else
    {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    设置当前的活动记录集
//    参数：    nRecordset        当前的活动记录集
//    返回值：none
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
void CAdo::SetActiveRecordset(int nRecordset)
{
    if (nRecordset >= 0 && nRecordset < m_pData->m_ppRec.size())
    {
        m_nActiveRS = nRecordset;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    打开数据库连接(使用ConnectString+用户名、密码的方式连接数据库)
//    参数：    nProvider        数据库驱动类型：
//                                1、Microsoft.Jet.OLEDB
//                                2、Microsoft.SQL.OLEDB
//                                3、ORACLE.OLEDB
//                                4、Microsoft.ODBC.OLEDB
//            strServer        数据库服务器名称(JET和ODBC该参数忽略)
//            strDatabase        数据库名称(JET：数据库文件名称；ODBC：DNS名称)
//            strUser            用户名称
//            strPass            登录密码
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::OpenConnect(int nProvider, CString strServer,
                CString strDatabase, CString strUser, CString strPass)
{
    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    CString strProvider;
    CString strCnnStr;

    if (m_pData->m_pCnn->State != adStateClosed)
    {
        return 3;
    }

    switch (nProvider)
    {
    case 1:
        //"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=databaseName;User ID=MyUserID;Password=MyPassword;"
        strProvider = "Microsoft.Jet.OLEDB.4.0";
        strCnnStr.Format("Provider=%s;Data Source=%s;",
            strProvider, strDatabase);
        break;
    case 2:
        //Provider=SQLOLEDB.1;Persist Security Info=False;User ID=sa;Initial Catalog=Northwind;Data Source=SPROLL
        //"Provider=SQLOLEDB;Data Source=serverName;"
        //Initial Catalog=databaseName;
        //User ID=MyUserID;Password=MyPassword;"
        //strProvider = "SQLOLEDB.1";
        strProvider = "SQLOLEDB";
        strCnnStr.Format("Provider=%s;Data Source=%s;Initial Catalog=%s;User ID=%s;Password=%s",
            strProvider, strServer, strDatabase, strUser,strPass);
        break;
    case 3:
        //"Provider=MSDAORA;Data Source=serverName;User ID=MyUserID; Password=MyPassword;"
        strProvider = "MSDAORA";
        strCnnStr.Format("Provider=%s;Data Source=%s;Initial Catalog=%s;User ID=%s;Password=%s",
            strProvider, strServer, strDatabase, strUser,strPass);
        break;
    case 4:
        //"Provider=MSDASQL;DSN=dsnName;UID=MyUserID;PWD=MyPassword;"
        strProvider = "MSDASQL";
        strCnnStr.Format("Provider=%s;DSN=%s;UID=%s;PWD=%s",
            strProvider, strDatabase, strUser,strPass);
        break;
    default:
        break;
    }

    try
    {
        if (FAILED(m_pData->m_pCnn->Open(strCnnStr.GetBuffer(), strUser.GetBuffer(),
            strPass.GetBuffer(), adConnectUnspecified)))
        {
            return 4;
        }
        m_strServer = strServer;
        m_strDatabase = strDatabase;
        m_strUser = strUser;
        m_strPass = strPass;
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    打开数据库连接(使用ConnectString的方式连接数据库)
//    参数：    strCnnStr        连接字符串
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::OpenConnect(CString strCnnStr)
{
    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    if (m_pData->m_pCnn->State != adStateClosed)
    {
        return 3;
    }

    try
    {
        if (FAILED(m_pData->m_pCnn->Open(strCnnStr.GetBuffer(), "", "", adConnectUnspecified)))
        {
            return 4;
        }
        m_strServer = "";
        m_strDatabase = "";
        m_strUser = "";
        m_strPass = "";
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    关闭数据库连接
//    参数：    strCnnStr        数据库连接字符串
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
void CAdo::CloseConnect()
{
    if (m_pData->m_pCnn != NULL)
    {
        try
        {
            if (m_pData->m_pCnn->State == adStateClosed)
            {
                return;
            }
            else
            {
                m_pData->m_pCnn->Close();
            }
        }
        catch(_com_error &e)
        {
            //SetSdkError(0, e.Error(), 0);
        }
    }
}

///////////////////////////////////////////////////////////////////////
//
//    开始事务
//    参数：    none
//    返回值：0                正确
//    时间：    2006-05-04
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::BeginTrans()
{
    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    if (m_pData->m_pCnn->State == adStateClosed)
    {
        return 3;
    }

    try
    {
        m_pData->m_pCnn->BeginTrans();
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    提交事务
//    参数：    none
//    返回值：0                正确
//    时间：    2006-05-04
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::CommitTrans()
{
    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    if (m_pData->m_pCnn->State == adStateClosed)
    {
        return 3;
    }

    try
    {
        m_pData->m_pCnn->CommitTrans();
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    取消事务
//    参数：    none
//    返回值：0                正确
//    时间：    2006-05-04
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::RollbackTrans()
{
    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    if (m_pData->m_pCnn->State == adStateClosed)
    {
        return 3;
    }

    try
    {
        m_pData->m_pCnn->RollbackTrans();
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    执行非数据选取SQL
//    参数：    strSql            SQL执行语句
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::Execute(CString strSql, int* pAffected)
{
    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    if (m_pData->m_pCnn->State == adStateClosed)
    {
        return 3;
    }

    _bstr_t bstrSql;
    _variant_t vtAffected;

    try
    {
        bstrSql = strSql;
        if (pAffected == NULL)
        {
            m_pData->m_pCnn->Execute(bstrSql, NULL, adCmdText | adExecuteNoRecords);
        }
        else
        {
            vtAffected.vt = VT_I4;
            m_pData->m_pCnn->Execute(bstrSql, &vtAffected, adCmdText | adExecuteNoRecords);
            *pAffected = vtAffected;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    执行(sql server 2000)数据库脚本文件
//    参数：    strFile            SQL脚本文件
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::ExecuteSqlFile(CString strFile)
{
    //函数内不检查strFile的存在性，外部调用者须保证此点
    //函数执行时，每次读取脚本文件中的10K长度的内容，执行完后，再进行下一次循环

    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    if (m_pData->m_pCnn->State == adStateClosed)
    {
        return 3;
    }

    //当前读取的脚本文件的位置
    int nReadPos = 0;
    //在循环时，当前读取操作读取的文件内容长度
    int nRead;
    //Sql脚本文件大小
    int nLen = 0;
    //临时变量，保存函数的返回值
    int nReturn;
    //查找GO关键字时，查找的起始位置
    int nStartIndex;
    //找到的GO关键字的位置
    int nGoPos;

    CString strRead;
    //GO关键字之间的，需要执行的SQL语句内容
    CString strSql;
    //上一次读取的脚本内容中，未尾未读取完、未执行的脚本内容
    CString strLeft;
    //将脚本中的GO关键字转换为大写的GO
    //通过查找脚本内容的所有带GO的词组，然后替换之
    CString strGoWordU = "/xd/xaGO/xd/xa";
    CString strGoWordUL = "/xd/xaGo/xd/xa";
    CString strGoWordLU = "/xd/xagO/xd/xa";
    CString strGoWordL = "/xd/xago/xd/xa";

    //每次读取脚本文件的10K大小内容，保存在缓冲区中
    BYTE* pucBuf = new BYTE[10241];

    CFile filSql;

    try
    {
        nReturn = filSql.Open(strFile, CFile::modeRead);
        if (nReturn)
        {
            nLen = (int)filSql.GetLength();
            while (nReadPos < nLen)
            {
                //每次读取脚本文件中的10K大小的内容，并执行
                pucBuf[0] = '/0';
                nRead = nReadPos + 10240 < nLen ? 10240 : nLen - nReadPos;

                filSql.Read(pucBuf, nRead);
                pucBuf[nRead] = '/0';
                nReadPos += nRead;

                nStartIndex = 0;
                strRead = strLeft + (CString)pucBuf;
                strRead.Replace(strGoWordUL, strGoWordU);
                strRead.Replace(strGoWordLU, strGoWordU);
                strRead.Replace(strGoWordL, strGoWordU);
                while (true)
                {
                    //执行两个GO之间的脚本内容
                    nGoPos = strRead.Find(strGoWordU, nStartIndex);
                    if (nGoPos >= 0)
                    {
                        if (nGoPos - nStartIndex > 0)
                        {
                            strSql = strRead.Mid(nStartIndex, nGoPos - nStartIndex);
                            strSql.Trim();
                            if (strSql.GetLength() > 0)
                            {
                                m_pData->m_pCnn->Execute(strSql.GetBuffer(), NULL, adCmdText | adExecuteNoRecords);
                            }
                        }
                        nStartIndex = nGoPos + 6;
                    }
                    else
                    {
                        if (strRead.GetLength() - nStartIndex > 0)
                        {
                            strLeft = strRead.Right(strRead.GetLength() - nStartIndex);
                        }
                        else
                        {
                            strLeft = "";
                        }
                        goto NextSegment;
                    }
                }
NextSegment:
                ;
            }
            filSql.Close();
        }
        else
        {
            delete [] pucBuf;
            return 5;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        delete [] pucBuf;
        return 1;
    }

    delete [] pucBuf;

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    打开记录集
//    参数：    strSql            SQL执行语句
//            nRecordset        返回记录集标识
//            nCursorType        游标类型：
//                                0，adOpenForwardOnly；
//                                1，adOpenKeyset；
//                                2，adOpenDynamic；
//                                3，adOpenStatic；
//            nLockType        锁定类型
//                                1，adLockReadOnly
//                                2，adLockPessimistic
//                                3，adLockOptimistic
//                                4，adLockBatchOptimistic
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::OpenRecordset(CString strSql, int &nRecordset, int nCursorType, int nLockType)
{
    if (m_pData->m_pCnn == NULL)
    {
        return 2;
    }

    if (m_pData->m_pCnn->State == adStateClosed)
    {
        return 3;
    }

    int nIndex = -1;

    for (int nCount = 0; nCount < m_pData->m_ppRec.size(); nCount++)
    {
        if (m_pData->m_ppRec[nCount]->State == adStateClosed)
        {
            nIndex = nCount;
            break;
        }
    }

    if (nIndex < 0)
    {
        _RecordsetPtr pResNew;
        pResNew.CreateInstance(__uuidof(Recordset));
        if (pResNew != NULL)
        {
            m_pData->m_ppRec.push_back(pResNew);
        }
        else
        {
            return 4;
        }
        nIndex = m_pData->m_ppRec.size() - 1;
    }

    _bstr_t bstrSql;
    try
    {
        bstrSql = strSql;
        m_pData->m_ppRec[nIndex]->CursorLocation = adUseClient;
        m_pData->m_ppRec[nIndex]->Open(bstrSql, _variant_t((IDispatch *)m_pData->m_pCnn, true),
            (CursorTypeEnum)nCursorType, (LockTypeEnum )nLockType, adCmdText);
        nRecordset = nIndex;
        m_nActiveRS = nIndex;
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    关闭记录集
//    参数：    nRecordset        记录集标识
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
void CAdo::CloseRecordset(int nRecordset)
{
    bool bMatch = false;
    int nSize = m_pData->m_ppRec.size();

    if (nRecordset >= 0 && nRecordset < nSize)
    {
        try
        {
            if (m_pData->m_ppRec[nRecordset]->State != adStateClosed)
            {
                m_pData->m_ppRec[nRecordset]->Close();
            }
            if (m_nActiveRS == nRecordset)
            {
                for (int nCount = 0; nCount < nSize; nCount++)
                {
                    if (m_pData->m_ppRec[nCount]->State != adStateClosed)
                    {
                        m_nActiveRS = nCount;
                        bMatch = true;
                        break;
                    }
                }
                if (!bMatch)
                {
                    m_nActiveRS = -1;
                }
            }
        }
        catch(_com_error &e)
        {
            //SetSdkError(0, e.Error(), 0);
        }
    }

    return;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集添加记录
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::Add()
{
    _variant_t vtEmpty(DISP_E_PARAMNOTFOUND, VT_ERROR);

    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->AddNew(vtEmpty, vtEmpty)))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集添加记录
//    参数：    pData            按顺序保存各字段的数值
//            nNum            数据数量
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::Add(const _variant_t *pValues, int nNum)
{
    int nReturn;

    nReturn = Add();
    if (nReturn)
    {
        return 2;//AddError(2, nReturn);
    }

    nReturn = SetRecordValue(pValues, nNum);
    if (nReturn)
    {
        return 3;//AddError(3, nReturn);
    }

    nReturn = Update();
    if (nReturn)
    {
        return 4;//AddError(4, nReturn);
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集删除当前游标所指的记录
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::Delete()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->Delete(adAffectCurrent)))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集更新当前游标所指的记录
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::Update()
{
    _variant_t vtEmpty(DISP_E_PARAMNOTFOUND, VT_ERROR);

    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->Update(vtEmpty, vtEmpty)))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集退出当前执行状态
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::Cancel()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->Cancel()))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集退出当前Update操作
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::CancelUpdate()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->CancelUpdate()))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    返回当前的活动记录集记录总数
//    参数：    none
//    返回值：                记录总数，-2为出错(不返回-1是因为Recordset会返回-1)
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::GetRecordCount()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return -2;
            }
            else
            {
                return m_pData->m_ppRec[m_nActiveRS]->RecordCount;
            }
        }
        else
        {
            return -2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return -2;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回当前的活动记录集BOF属性
//    参数：    none
//    返回值：                BOF
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
bool CAdo::GetBOF()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return true;
            }
            else
            {
                return m_pData->m_ppRec[m_nActiveRS]->BOF;
            }
        }
        else
        {
            return true;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return true;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回当前的活动记录集EOF属性
//    参数：    none
//    返回值：                EOF
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
bool CAdo::GetEOF()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return true;
            }
            else
            {
                return m_pData->m_ppRec[m_nActiveRS]->EndOfFile;
            }
        }
        else
        {
            return true;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return true;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集移动至第一条记录
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::MoveFirst()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->MoveFirst()))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集移动至最后一条记录
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::MoveLast()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->MoveLast()))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集移动至上一条记录
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::MovePrev()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->MovePrevious()))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集移动至下一条记录
//    参数：    none
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::MoveNext()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->MoveNext()))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    当前的活动记录集移动至指定记录
//    参数：    nNum            移动的记录数目
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::Move(int nNum)
{
    _variant_t vtBookmark = (LONG)adBookmarkFirst;
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->Move(nNum, vtBookmark)))
                {
                    return 4;
                }
            }
        }
        else
        {
            return 2;
        }
    }
    catch(_com_error &e)
    {
        CString s = e.Description();
        //SetSdkError(0, e.Error(), 0);
        return 1;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////
//
//    返回字段数目
//    参数：    none
//    返回值：正数            正确
//            -1                错误
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::GetFieldsCount()
{
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return -1;
            }
            else
            {
                return m_pData->m_ppRec[m_nActiveRS]->Fields->Count;
            }
        }
        else
        {
            return -1;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return -1;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回字段名称
//    参数：    nInd            字段序号，从0开始
//    返回值：                字段名称，如果出错返回空字符串
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
CString CAdo::GetFieldName(int nInd)
{
    _variant_t vtInd = (short)nInd;
    FieldPtr pField;
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return "";
            }
            else
            {
                if (nInd >= 0 && nInd < m_pData->m_ppRec[m_nActiveRS]->Fields->Count)
                {
                    pField = m_pData->m_ppRec[m_nActiveRS]->Fields->GetItem(&vtInd);
                    return pField->Name;
                }
                else
                {
                    return "";
                }
            }
        }
        else
        {
            return "";
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return "";
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回字段类型
//    参数：    nInd            字段序号，从0开始
//    返回值：                字段类型，如果出错返回-1
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::GetFieldType(int nFieldInd)
{
    _variant_t vtInd = (short)nFieldInd;
    FieldPtr pField;
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return -1;
            }
            else
            {
                if (nFieldInd >= 0 && nFieldInd < m_pData->m_ppRec[m_nActiveRS]->Fields->Count)
                {
                    pField = m_pData->m_ppRec[m_nActiveRS]->Fields->GetItem(&vtInd);
                    return pField->Type;
                }
                else
                {
                    return -1;
                }
            }
        }
        else
        {
            return -1;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return -1;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回字段数值
//    参数：    nRecordInd        记录序号，从0开始
//            nFieldInd        字段序号，从0开始
//    返回值：                字段数值，如果出错返回NULL变体
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
_variant_t CAdo::GetFieldValue(int nRecordInd, int nFieldInd)
{
    _variant_t vtBookmark = (LONG)adBookmarkFirst;
    _variant_t vtInd = (short)nFieldInd;
    _variant_t vtNull;
    vtNull.vt = VT_NULL;
    FieldPtr pField;

    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return vtNull;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiveRS]->Move(nRecordInd, vtBookmark)))
                {
                    return vtNull;
                }
                if (m_pData->m_ppRec[m_nActiveRS]->EndOfFile
                    || m_pData->m_ppRec[m_nActiveRS]->BOF)
                {
                    return vtNull;
                }
                if (nFieldInd >= 0 && nFieldInd < m_pData->m_ppRec[m_nActiveRS]->Fields->Count)
                {

                    pField = m_pData->m_ppRec[m_nActiveRS]->Fields->GetItem(&vtInd);
                    return pField->Value;
                }
                else
                {
                    return vtNull;
                }
            }
        }
        else
        {
            return vtNull;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return vtNull;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回字段数值
//    参数：    nFieldInd        字段序号，从0开始
//    返回值：                字段数值，如果出错返回NULL变体
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
_variant_t CAdo::GetFieldValue(int nFieldInd)
{
    _variant_t vtInd = (short)nFieldInd;
    _variant_t vtNull;
    vtNull.vt = VT_NULL;
    FieldPtr pField;

    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return vtNull;
            }
            else
            {
                if (m_pData->m_ppRec[m_nActiveRS]->EndOfFile
                    || m_pData->m_ppRec[m_nActiveRS]->BOF)
                {
                    return vtNull;
                }
                if (nFieldInd >= 0 && nFieldInd < m_pData->m_ppRec[m_nActiveRS]->Fields->Count)
                {
                    pField = m_pData->m_ppRec[m_nActiveRS]->Fields->GetItem(&vtInd);
                    return pField->Value;
                }
                else
                {
                    return vtNull;
                }
            }
        }
        else
        {
            return vtNull;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return vtNull;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回字段数值
//    参数：    strField        字段名称
//    返回值：                字段数值，如果出错返回NULL变体
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
_variant_t CAdo::GetFieldValue(CString strField)
{
    _variant_t vtField;
    _variant_t vtNull;
    vtNull.vt = VT_NULL;
    FieldPtr pField;

    vtField = strField;
    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return vtNull;
            }
            else
            {
                if (m_pData->m_ppRec[m_nActiveRS]->EndOfFile
                    || m_pData->m_ppRec[m_nActiveRS]->BOF)
                {
                    return vtNull;
                }
                if (!strField.IsEmpty())
                {
                    pField = m_pData->m_ppRec[m_nActiveRS]->Fields->GetItem(&vtField);
                    return pField->Value;
                }
                else
                {
                    return vtNull;
                }
            }
        }
        else
        {
            return vtNull;
        }
    }
    catch(_com_error &e)
    {
        //SetSdkError(0, e.Error(), 0);
        return vtNull;
    }
}

///////////////////////////////////////////////////////////////////////
//
//    返回一条记录的数值
//    参数：    nRecordInd        记录序号，从0开始
//            pValues            顺序保存每个字段数据的数组
//            nNum            数组大小，如果小于字段数量，则只拷贝nNum大小的数据
//    返回值：0                正确
//    时间：    2006-02-09
//    版本：    1.0
//    历史：
//
///////////////////////////////////////////////////////////////////////
int CAdo::GetRecordValue(int nRecordInd, _variant_t *pValues, int nNum)
{
    _variant_t vtBookmark = (LONG)adBookmarkFirst;
    _variant_t vtInd;

    FieldPtr pField;

    int nFieldCount;
    int nGetCount;

    try
    {
        if (m_nActiveRS >= 0 && m_nActiveRS < m_pData->m_ppRec.size())
        {
            if (m_pData->m_ppRec[m_nActiveRS]->State == adStateClosed)
            {
                return 3;
            }
            else
            {
                if (FAILED(m_pData->m_ppRec[m_nActiv

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞