我封装的一个ADO类,使用超简单!

最新推荐文章于 2016-06-20 14:52:56 发布
原创 最新推荐文章于 2016-06-20 14:52:56 发布 · 3.6k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#null #sql server #sql #float #microsoft #ui

我封装的一个ADO类,使用超简单!

把以下代码保存为ado.h,#include进去就可以用了.

/*
摘要:ADO封装类.(为了方便引用, ado.h包含了两个主要类 CADOConnection, CADORecordet)
版本:1.0
作者:魏孙鼎
日期:2005-6-25

简单用法:

CADOConnection cn;
cn.OpenMSSQL(...);

COleDateTime dt = COleDateTime::GetCurrentTime();

CADORecordset rs;
rs.Open("select * from table",cn,false);
rs.AddNew();
rs["Field1"] = "文本值";
rs["IntVal"] = 123;
rs["Image"].AppendBinary(...);
rs["DateVal"] = dt;
rs.Update();

rs.Close();
cn.Close();

*/

  
 
把以下代码保存为ado.h,#include进去就可以用了.

/*
摘要:ADO封装类.(为了方便引用, ado.h包含了两个主要类 CADOConnection, CADORecordet)
版本:1.0
作者:魏孙鼎
日期:2005-6-25

简单用法:

CADOConnection cn;
cn.OpenMSSQL(...);

COleDateTime dt = COleDateTime::GetCurrentTime();

CADORecordset rs;
rs.Open("select * from table",cn,false);
rs.AddNew();
rs["Field1"] = "文本值";
rs["IntVal"] = 123;
rs["Image"].AppendBinary(...);
rs["DateVal"] = dt;
rs.Update();

rs.Close();
cn.Close();

*/

 

#pragma once
#pragma warning(disable:4800)
#pragma warning(disable:4101)

#import "c:/Program Files/Common Files/System/ado/msado15.dll" no_namespace, rename("EOF","IsEOF")
#include <atlstr.h>
#include <ATLComTime.h>

//-----------------------------------------------------
// 声明部分
//-----------------------------------------------------
CString vartostr(const _variant_t &var);
class CADOConnection
{
private:
 bool m_bIsOpen;
 void Init();
public:
 //---------- Members -------------------
 _ConnectionPtr m_lpConnection; 
 CString ConnectString;
 //--------------------------------------

 CADOConnection(void);
 CADOConnection(const char* lpConnStr);
 CADOConnection(CString szConnStr); 

 bool IsOpen();
 bool Open(const char* lpConnStr);
 bool Open(CString szConnStr);
 bool Open();
 bool OpenMSSQL(const char* lpServer, const char* lpUserID, const char* lpPassword, const char* lpDataBase);
 bool OpenOracle(const char* lpDataSource, const char* lpUserID, const char* lpPassword);
 bool OpenAccess(const char* lpDbFile, const char* lpPassword = "");
 _RecordsetPtr Execute(CString sql, long* recordsAffected = NULL);


 //----------完成部分-------------------
 ~CADOConnection(void);
 void Close();
 void Release();
 //-------------------------------------

 void BeginTrans()   { m_lpConnection->BeginTrans();   }
 void CommitTrans()  { m_lpConnection->CommitTrans();  }
 void RollbackTrans(){ m_lpConnection->RollbackTrans();} 

};


class DbField : public _variant_t
{ 
public:

 // -- Members ---------------
 FieldPtr m_lpField;
 //---------------------------

 DbField(FieldPtr& lpField) :_variant_t(lpField->Value)
 {
  m_lpField = lpField;        
 }

 DbField()
 {
  
 }

 void Attach(FieldPtr& lpField)
 {
  m_lpField = lpField; 
  _variant_t::Attach(m_lpField->Value);  
 }

 bool IsNull()
 {
  return (m_lpField->Value.vt == VT_NULL);
 }

 CString GetName()
 { 
  CString s = m_lpField->GetName().GetBSTR();    
  return s;
 }

 long GetActualSize()
 {
  return m_lpField->ActualSize;
 }

 CString ToString()
 {
  return vartostr(m_lpField->Value);
 }
 
 ~DbField()
 {
 
 }

    void operator=(_variant_t& value)   { m_lpField->put_Value(_variant_t(value)); }
 void operator=(int &value)     { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const int &value)   { m_lpField->put_Value(_variant_t(value)); }
 void operator=(unsigned int &value)   { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const unsigned int &value) { m_lpField->put_Value(_variant_t(value)); }
 void operator=(long &value)     { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const long &value)   { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const unsigned long &value) { m_lpField->put_Value(_variant_t(value)); }
 void operator=(unsigned long &value)  { m_lpField->put_Value(_variant_t(value)); }
 void operator=(float &value)    { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const float &value)   { m_lpField->put_Value(_variant_t(value)); }
 void operator=(double &value)    { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const double &value)   { m_lpField->put_Value(_variant_t(value)); }
 void operator=(char* value)     { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const char* value)   { m_lpField->put_Value(_variant_t(value)); }
 void operator=(const unsigned char* value) { m_lpField->put_Value(_variant_t(value)); }

 //字符串运算,写入日期也可以直接写入字符串日期
 void operator=(CString &value)
 {
  char* text = value.GetBuffer();
  m_lpField->put_Value(_variant_t(text));  
  value.ReleaseBuffer();
 }

 //写入日期
 void operator=(COleDateTime &dt)
 {
  CString strDate = dt.Format("%Y-%m-%d %H:%M:%S");
  char* lpDate = strDate.GetBuffer();
  m_lpField->put_Value(_variant_t(lpDate));
  strDate.ReleaseBuffer();
 }

 //向字段追加二进制数据
 bool AppendBinary(LPVOID lpData, UINT nBytes)
 {
  SAFEARRAY FAR *pSafeArray = NULL;
  SAFEARRAYBOUND rgsabound[1];

  try
  {
   rgsabound[0].lLbound = 0;
   rgsabound[0].cElements = nBytes;
   pSafeArray = SafeArrayCreate(VT_UI1, 1, rgsabound);

   for (long i = 0; i < (long)nBytes; i++)
   {
    UCHAR &chData = ((UCHAR*)lpData)[i];
    HRESULT hr = SafeArrayPutElement(pSafeArray, &i, &chData);
    if (FAILED(hr)) return FALSE;
   }

   _variant_t varChunk;
   varChunk.vt = VT_ARRAY | VT_UI1;
   varChunk.parray = pSafeArray;

   return (m_lpField->AppendChunk(varChunk) == S_OK);
  }
  catch (_com_error &e)
  {   
   return false;
  }
 }

 //取出二进制数据
 bool GetBinary(LPVOID lpData)
{
 assert(m_lpField != NULL);
 assert(lpData != NULL);

 UCHAR chData;
 long index = 0;

 while (index < m_lpField->ActualSize)
 { 
  try
  {
   _variant_t varChunk = m_lpField->GetChunk(100);
   if (varChunk.vt != (VT_ARRAY | VT_UI1))
   {
    return FALSE;
   }
   
            for (long i = 0; i < 100; i++)
            {
                if (SUCCEEDED( SafeArrayGetElement(varChunk.parray, &i, &chData) ))
                {
     ((UCHAR*)lpData)[index] = chData;
                    index++;
                }
                else
    {
                    break;
    }
            }
  }
  catch (_com_error& e)
  {
   return FALSE;
  }
 }

 return TRUE;
}

};


class CADORecordset
{
private:
 void Init();
 DbField field;
public:
 // --- Members ----------------
 _RecordsetPtr m_lpRecordset;
 //----------------------------
 CADORecordset(); 
 CADORecordset(_RecordsetPtr& lpRecordset);  
 ~CADORecordset(void);
 void Attach(_RecordsetPtr& lpRecordset);

 void MoveFirst();
 void MoveLast();
 void MoveNext();
 void MovePrev();
 void Move(long rowIndex);
 void AddNew();
 bool Update();
 bool Open(CString sql, CADOConnection &conn, bool forReadOnly = true);
 void Requery() { m_lpRecordset->Requery(adOptionUnspecified);}
 void Close()   { m_lpRecordset->Close(); }
 long GetRecordCount() { return m_lpRecordset->RecordCount; } 
 bool IsEOF() { return m_lpRecordset->IsEOF; }
 bool IsBOF() { return m_lpRecordset->BOF; }

 //运算符重载------------------------------
 DbField& operator[](const char* fieldName)
 {
  field.Attach(m_lpRecordset->GetFields()->GetItem(_variant_t(fieldName)));
  return field;
 }
};


//-----------------------------------------------------
// CADOConnection  实现 
//-----------------------------------------------------
void CADOConnection::Init()
{ 
 CoInitialize(NULL);

 m_bIsOpen = false;
 ConnectString = "";
 m_lpConnection = NULL;
 m_lpConnection.CreateInstance("ADODB.Connection"); 
}

CADOConnection::CADOConnection()
{
 Init();
}

CADOConnection::CADOConnection(const char* lpConnStr)
{
 Init();
 ConnectString = lpConnStr; 
}

CADOConnection::CADOConnection(CString szConnStr)
{
 Init();
 ConnectString = szConnStr; 
}

bool CADOConnection::IsOpen()
{
 return m_bIsOpen;
}

bool CADOConnection::Open(const char* lpConnStr)
{ 
 ConnectString = lpConnStr;
 return Open();
}

bool CADOConnection::Open(CString szConnStr)
{
 ConnectString = szConnStr;
 return Open();
}

bool CADOConnection::Open()
{
 if ( ConnectString == "")
  return false;

 char * lpConnStr = ConnectString.GetBuffer();

 try
 {
  m_bIsOpen = (m_lpConnection->Open(lpConnStr, "", "", NULL) == 0);
 }
 catch(_com_error &e)
 {
  m_bIsOpen = false; 
  throw e;
 }
 
 ConnectString.ReleaseBuffer();
 
 return m_bIsOpen; 
}

//打开Microsoft Sql Server
bool CADOConnection::OpenMSSQL(const char* lpServer, const char* lpUserID, 
          const char* lpPassword, const char* lpDataBase)
{ 
 ConnectString.Format("driver={sql server};server=%s;uid=%s;pwd=%s;database=%s",
       lpServer, lpUserID, lpPassword, lpDataBase);
    return Open();

}


//打开Oracle数据库(客户端要先安装Oracle Client),lpDataSource指对应服名
bool CADOConnection::OpenOracle(const char* lpDataSource, const char* lpUserID, const char* lpPassword)
{ 
 ConnectString.Format("Provider=OraOLEDB.Oracle;Data Source=%s;User Id=%s;Password=%s;", 
       lpDataSource, lpUserID, lpPassword);       
       
    return Open();
}

//打开Access数据库
bool CADOConnection::OpenAccess(const char* lpDbFile, const char* lpPassword)
{
 ConnectString.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=%s;User Id=admin;Password=%s;" ,
      lpDbFile, lpPassword);
 return Open();
}

void CADOConnection::Close()
{
 if (m_lpConnection != NULL && IsOpen())
 {
  m_lpConnection->Close(); 
  m_bIsOpen = false;
 }
}

void CADOConnection::Release()
{
 Close();

 if (m_lpConnection != NULL)
 {
  m_lpConnection.Release();
  m_lpConnection = NULL;
 }
}

CADOConnection::~CADOConnection()
{
 Release();
 CoUninitialize();  
}

_RecordsetPtr CADOConnection::Execute(CString sql, long* recordsAffected)
{ 
 char* lpText = sql.GetBuffer();
  _variant_t d(0);  
 
  _RecordsetPtr lpRec = m_lpConnection->Execute(_bstr_t(lpText),&d , NULL);
 
  sql.ReleaseBuffer();
 if (recordsAffected != NULL)
 {
  *recordsAffected = d.lVal;
 }
    
 return lpRec;
}

//-----------------------------------------------------
// CADORecordset  实现 
//-----------------------------------------------------

void CADORecordset::Init()
{
 m_lpRecordset = NULL;
 m_lpRecordset.CreateInstance("ADODB.Recordset");  
}

CADORecordset::CADORecordset()
{
 Init();
}

CADORecordset::CADORecordset(_RecordsetPtr& lpRecordset)
{
 Init();
 m_lpRecordset = lpRecordset;
}


CADORecordset::~CADORecordset()
{
 if( m_lpRecordset != NULL)
 {
  m_lpRecordset.Release(); 
 }
}

void CADORecordset::Attach(_RecordsetPtr& lpRecordset)
{
 if (m_lpRecordset != NULL)
  m_lpRecordset.Release();

 m_lpRecordset = lpRecordset;
}

void CADORecordset::MoveFirst()
{
 m_lpRecordset->MoveFirst();
}

void CADORecordset::MoveLast()
{
 m_lpRecordset->MoveLast();
}


void CADORecordset::MoveNext()
{
 m_lpRecordset->MoveNext();
}


void CADORecordset::MovePrev()
{
 m_lpRecordset->MovePrevious();
}

void CADORecordset::Move(long rowIndex)
{
 m_lpRecordset->Move(rowIndex);
}

void CADORecordset::AddNew()
{
 m_lpRecordset->AddNew();
}

bool CADORecordset::Update()
{
 return m_lpRecordset->Update() == 0;
}

bool CADORecordset::Open(CString sql,CADOConnection &conn, bool forReadOnly)
{
 char * sqlText = sql.GetBuffer(); 
 
 if( forReadOnly)
 {
  m_lpRecordset->Open(sqlText,(IDispatch*)conn.m_lpConnection, adOpenStatic, adLockReadOnly, NULL);  
 }
 else
 {
  m_lpRecordset->Open(sqlText, (IDispatch*)conn.m_lpConnection,adOpenStatic, adLockOptimistic, NULL);
 }

 sql.ReleaseBuffer();

 return true;
}

//----------------------------------------------------
//函数实现
//----------------------------------------------------

CString vartostr(const _variant_t &var)
{
 CString strValue;
 
 switch (var.vt)
 {
 case VT_BSTR://字符串
 case VT_LPSTR://字符串
 case VT_LPWSTR://字符串
  strValue = (LPCTSTR)(_bstr_t)var;
  break;
 case VT_I1:
 case VT_UI1:
  strValue.Format("%d", var.bVal);
  break;
 case VT_I2://短整型
  strValue.Format("%d", var.iVal);
  break;
 case VT_UI2://无符号短整型
  strValue.Format("%d", var.uiVal);
  break;
 case VT_INT://整型
  strValue.Format("%d", var.intVal);
  break;
 case VT_I4: //整型
  strValue.Format("%d", var.lVal);
  break;
 case VT_I8: //长整型
  strValue.Format("%d", var.lVal);
  break;
 case VT_UINT://无符号整型
  strValue.Format("%d", var.uintVal);
  break;
 case VT_UI4: //无符号整型
  strValue.Format("%d", var.ulVal);
  break;
 case VT_UI8: //无符号长整型
  strValue.Format("%d", var.ulVal);
  break;
 case VT_VOID:
  strValue.Format("%8x", var.byref);
  break;
 case VT_R4://浮点型
  strValue.Format("%.4f", var.fltVal);
  break;
 case VT_R8://双精度型
  strValue.Format("%.8f", var.dblVal);
  break;
 case VT_DECIMAL: //小数
  strValue.Format("%.8f", (double)var);
  break;
 case VT_CY:
  {
   //货币型保留四位小数
   strValue.Format("%.4f", (float)((float)var.cyVal.int64 / (float)10000));   
  }
  break;
 case VT_BLOB:
 case VT_BLOB_OBJECT:
 case 0x2011:
  strValue = "[BLOB]";
  break;
 case VT_BOOL://布尔型
  strValue = var.boolVal ? "TRUE" : "FALSE";
  break;
 case VT_DATE: //日期型
  {
   DATE dt = var.date;
   COleDateTime da = COleDateTime(dt); 
   strValue = da.Format("%Y-%m-%d %H:%M:%S");     
  }
  break;
 case VT_NULL://NULL值
  strValue = "";
  break;
 case VT_EMPTY://空
  strValue = "";
  break;
 case VT_UNKNOWN://未知类型
 default:
  strValue = "UN_KNOW";
  break;
 }
 return strValue;
}
ADO.NET常见面试题
wuke666666的博客
03-30 1807
ADO.NET模块测试 1.ADO.NET中读写数据库需用到哪些对象？作用是什么？ DataConnection 连接数据库 DataCommand 执行语句命令 DataSet 数据存储器 DataAdapter 适配器，用于填充数据 DataReader 数据读取器，用于向前只读的数据流 2.写出一条SQL语句：取出Student表中第31到第40条数据（以自动增长的ID作为主键，主键可能...
VC++财务管理系统实战详解
最新发布
weixin_42513209的博客
08-11 662
在现代软件开发中，数据库的集成对于应用程序的实用性和性能是至关重要的。Visual C++（简称VC++），一个功能强大的C++开发环境，与易于使用的Microsoft Access数据库的结合，为快速开发小型到中型的桌面或客户端/服务器应用程序提供了一个极佳的解决方案。ADO（ActiveX Data Objects）是一个用于访问和操作数据库中的数据的COM组件。它为开发人员提供了一组丰富的对象模型，可以用来连接、查询和操作数据源。
ADO简单封装类
chinabinlang的专栏
06-20 1018
class CGADO { public: CGADO() { pConnection = NULL; pRecordset  = NULL; OpenDB(); } ~CGADO() { CloseDB(); } private: _ConnectionPtr pConnection ; _RecordsetPtr pRecordset
ADO封装类（封装三大对象Connection、Recordset 、Command）
05-18
ADO中最重要的对象有三个：Connection、Command和Recordset，它们分别表示连接对象、命令对象和记录集对象。本压缩文件包含6个文件，3个cpp，3个头文件。完美实现对ADO的封装。
ADO C++封装类
06-19
一个ADO的封装类。封装了VC++中的三个智能指针。头文件中有使用说明
ado.h源代码
11-15
C++源文件下载，ado访问数据库封装类ado.h
Visual C++编程封装ADO类
大伟的代码空间
12-26 1256
 1 引言在过去几年中，微软公司相继推出了几种数据访问技术，先是DAO（Data Access Objects），然后是RDO（Remote Data Objects）,现在是ADO（ActiceX Data Objects）。ADO是Microsoft数据库应用程序开发的新接口，是微软最新的数据访问技术。它被设计用来同新的数据访问层OLE DB Provider一起协同工作，以提供通用数
老外写的ADO封装类
08-03
老外写的ADO封装类，超全面，使用简单。经过长期测试，使用中相当稳定。
简易ADO类实现数据库高效操作（附源码及常见问题解答）
- 该标题暗示存在一个预先设计好的类，用于简化数据库操作，可能封装了ADO的复杂性，使得开发者能够更简单地实现数据库的读写操作。 - 这个类可能提供了一些便捷的方法来执行常用的数据库操作，例如打开、关闭...
C++实现ADO技术封装，操作MySQL、SqlServer等多种数据库
资源摘要信息:"本资源是一套使用C++语言封装的ADO技术，实现了...通过以上知识点的介绍，初学者可以对使用C++封装ADO连接和操作多种数据库系统有一个系统和全面的认识，进而在实际开发中更加灵活和高效地运用相关技术。
c++ ADO封装类c++ ADO封装类c++ ADO封装类
08-13
c++ ADO封装类 c++ ADO封装类c++ ADO封装类c++ ADO封装类c++ ADO封装类 增删查改
C++ ADO封装类.
12-05
C++ ADO封装类.C++ ADO封装类.C++ ADO封装类.C++ ADO封装类.C++ ADO封装类.
小而强悍的C++ ADO封装类
08-05
最近找到一个不错的ado封装类，很小但功能很强，而且可以自己动手继续完善，适合在一些小的项目中使用，哈哈
MFC封装的ADO类
01-14
下载的ADO类，我做了许多修改，在Visual Studio 2013 C++ MFC（使用Unicode 字符集）测试通过，可以直接使用。
ado 封装类 visual c++
01-02
非常优秀的 ado 封装类，很好用的，呵呵
ASP超级分页类实现高效Recordset分页处理
根据提供的文件信息，我们可以了解到一个关于ASP...通过一个分页类文件和一个测试文件，该类封装了分页功能，能够快速有效地处理Recordset对象，大大提升开发效率，体现了一种高效、专业的编程实践和代码复用的理念。
封装ADO操作数据库类
friendan的专栏
11-22 1823
//在类的头文件引入ADO类库 #inport "C:\\Programs Files\\Common Files\\System\\ado\\msado15.dll" no_namespace rename("EOF","adoEOF") rename("BOF","adoEOF")  class  CADOConn { public:    _ConnectionPtr  m_pCo
ADO数据库操作的C++封装
Midapexsoft
01-25 2515
 工程下载：http://www.cppblog.com/Files/dyj057/AdoDbv1.0-2007-1-25.rar前几日看到有位大哥发布的ADO数据库的封装，到处是模板，不免有些头晕，想起自己写的ADO数据库封装了，首先声明没有模板。但根据我3年使用的经验，确实很实用，特点：l         多线程安全的。l         使用标准C++数据类型，屏蔽了co
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值