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

我封装的一个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;
}