CSDN博客

img seesi

封装ADO访问数据库的两个类

发表于2002/3/27 8:48:00  809人阅读

 


 


 


 


 


 


    对于初学者,使用ADO访问数据库的时候,涉及到各种数据类型转换,可能有一些难度,我试图封装了ADO访问数据库,使其更方便的用现有的VC的数据类型,更加方便的使用ADO操作数据库。
下面分别提供两个封装ADO数据库访问的类,一个是数据库的连接类,一个是数据库字段访问的类。


   在连接类中,大家可以看到,连接类中并没有Recordset的成员变量,因为这样的,在整个数据库应用程序中,数据库的连接一般一个就够了,而同时打开的Reocordset则可能不只一个,所以,如果两个在同一个类里,那么,如果要同时打开两个记录集,需要建立类的两个实例,就是需要同时打开两个数据库连接,如果对于连接的是同一个数据库,同时打开两个连接的话,意味着资源的不必要的浪费。


   数据库字段访问类,简化了,获取数据库字段内容的操作,避免了数据类型转换的麻烦。


   两个类都对错误处理进行了较多的考虑,在访问数据库中,如果没有错误处理,其害处是显而易见的。


 



#ifndef _BBADOCONNECT_H
#define _BBADOCONNECT_H


//
// ADO访问数据库类
// 软件环境:需要MSADO15.DLL
// 作者:邓振波
// 2001.4.20
// Email:seesi@
163.com
//主页:seesi.51.net


// 说明:封装了ADO使用的操作函数和ADO访问数据库错误处理
//  使在VC上方便的使用ADO访问数据库
// 包括:ADO连接数据库、打开记录集、执行SQL、以及
//  事务处理、ADO记录集内容转换成C++的常用数据类型(
CString、char,long,float等)
//
// 使用:1。定义一个CBBAdoConnection实例:CBBAdoConnection
m_adoConn;
//  2。建立连接:m_adoConn.Open(strConnstring);
//     如果需要无条件重新连接的可
以,参数bRepen设成TREU
//  3。打开记录集:
//
//   _RecordsetPtr* prsThis=NULL;
//   prsThis=new _RecordsetPtr;
//   CString strSQL;
//   strSQL="select * from Table_Name";// 
//   如果记录集打开失败
//  


if(!(m_adoConn.OpenRecordset(strSQL,prsThis)))
//    return FALSE;
//  4。建立记录集值对象
//   注意需要用参数构造
//   CBBRstValues rsv(m_adoConn,prsThis);
// 
//  5。获得的字段的值
//   rsv.GetValueLong(&m_nDeptID,1L);//获得第一
个字段的值
//   rsv.GetValueStr(m_strName,"ID");//获得第一
个字段名为ID的值
//   其它的同理.如果需要获得SQL Server中
nText类型的字段值请用
//   GetValText(CString &strText, CString
&strFieldName)函数
//  6。记录集的记录移动 (*prsThis)->MoveNext()等类
似函数
//  7。记录集不用时候需要释放其资源
//   1)关闭记录集
//   2)删除记录集指针
//   e.g. (*prsThis)->Close();
//     delete prsThis;
//     prsThis=NULL;
//   否则会造成内存泄漏
// 
//  注:
//   1。程序必须要初始化COM环境,请在应用类中加
入AfxOleInit函数初始化环境,否则ADO的调用将失败
//   2。如果需要调用存储过程SQL语句改为“Exec ”
+ 存储过程名即可,与执行SQL同样
//
//                 CopyRight seesi,2001
//
//      说明:你可以随便在的程序中任意使用、修改本代码,但请你不要删
除文件头的部分说明。如果需要转载,请注明出处。
// msado15.dll必须放在本文件所在目录,或者自己指定下面的msado15.dll
全路径
//


#if !defined(__AFXADO_H)
#import "msado15.dll" no_namespace rename ("EOF", "adoEOF") /
  rename ("LockTypeEnum", "adoLockTypeEnum") /
  rename ("DataTypeEnum", "adoDataTypeEnum") /
  rename ("FieldAttributeEnum",


"adoFieldAttributeEnum") /
  rename ("EditModeEnum", "adoEditModeEnum") /
  rename ("RecordStatusEnum", "adoRecordStatusEnum")


/
  rename ("ParameterDirectionEnum",


"adoParameterDirectionEnum")
#endif  // !defined(__AFXADO_H)



class CBBAdoConnection 
{
public:
 CBBAdoConnection();
 virtual ~CBBAdoConnection();
public:
 int SetConnTimeOut(long lTimeOut); // 设置连接超时
 
int SetCommTimeOut(long lTimeOut); // 设置命令执行超时
 BOOL IsConnectClose(); // 判断连接是否已经打开
 int ExecuteSQL(LPCSTR szSQL); // 简单执行SQL语句,不返回记录
 // 打开数据库记录集
 // 参数:
 //  strSQL  记录集的SQL语句
 //  rs   返回的记录集_RecordsetPtr对象
 //  sConnString 数据库的连接字符串
 //     如果使用数据库连接已经打开,参数没用
 //     如果数据库的连接没有打开,当给予一个连接字符串,将先打开数据库连接
 BOOL OpenRecordset(CString strSQL, _RecordsetPtr *rs,CString sConnString="");//打开数据库记录集
 BOOL OpenRecordset(const char *sSQL,_RecordsetPtr* rs,char* sConnString=NULL);


 // 打开数据库连接
 // 参数:
 //  strConnString 连接字符串
 //  sConnString  连接字符串
 //  bReOpen   是否重新打开,如果
为FALSE,,
 //      将先判断数
据库是否打开如果没有打开则打开,
 //      如果已经打
开,将不执行任何操作
 //      如果为TRUE
,则无条件重新打开。
 
BOOL OpenConnection(CString strConnString ,BOOL bReOpen=FALSE);
 BOOL OpenConnection(char* sConnString,BOOL bReOpen=FALSE); void CloseConnect();// 关闭数据库连接


 BOOL ExecuteTrans(CStringArray arrStrSQL); // 事务处理,不返回任何记录集,参数为事务SQL数组



 _ConnectionPtr* GetConnection(); // 得到_ConnectionPtr指针
 CString GetConnString(); // 得到连接字符串
private:
 enum ERRORFrom {
     ErrFormOpenConnsction,
     ErrFromOpenRecordset,
     ErrFormCloseConnection,
     ErrFormTanslation
     };
 _ConnectionPtr* m_pConn;
 char m_szConnString[512];
 ///
protected:
 void ReportError(int nERRORfrom);
};



class CBBRstValues 
{
public:
 // 三种构造类的方法
 // 如果无参数构造,请构造后调用InitConnectAndRst方法
 // 其他的两种构造则不需调用InitConnectAndRst方法
 
CBBRstValues();
 CBBRstValues(_ConnectionPtr* pConn,_RecordsetPtr* pRs);
 CBBRstValues(CBBAdoConnection* pBBadoConn,_RecordsetPtr*


pRs);


 virtual ~CBBRstValues();
public:
 // 初始化连接队象和记录集对象
 void InitConnectAndRst(_ConnectionPtr* pConn,_RecordsetPtr*  pRs);
 void InitConnectAndRst(CBBAdoConnection* pBBAdoConn, _RecordsetPtr *  Rs);


 // GetValText函数
 // 得到数据库nText字段的值
 // 参数:
 //  strText   用来接收返回值(字段值)
 //  strFieldName 字段名,该字段数据类型必须是nText类型
 BOOL GetValText(CString& strText,CString& strFieldName); //得到数据库nText字段的值
 
 // GetValueStr函数
 // 得到数字型,日期型和字符型字段值函数
 // 参数:
 //  cVal   用来接收返回值(字段值)的字符串指针,要求要开辟足够的内存单元
 //      或者足够容纳字段内容的字符数组。
 //  vIndex   数据库字段的名字或者索引,变体型,一般不直接用这个参数,
 //      应该用同形式的多态函数的参数调用
 //      数据库字段的数据类型可以是数字型,日期型和字符型
 //  nFieldLen  需要返回的数据的字符串的长度,如果为-1,则返回整个字段值
 //  lpszFieldName 字段名,数据库字段的数据类型可以是数字型,日期型和字符型
 //  nFieldIndex  在SQL语句中字段的索引序号数据库字段的数据类型可以是数字型,日期型和字符型


 // GetValueLong函数
 // 得到数字型,日期型和字符型字段值函数
 // 参数:
 //  lVal   用来接收返回值(字段值)
 //  vIndex   数据库字段的名字或者索引,变体型,一般不直接用这个参数,
 //      应该用同形式的多态函数的参数调用
 //      数据库字段的数据类型要求是数字型(int,long)
 //  lpszFieldName 字段名,数据库字段的数据类型可以是数字型,日期型和字符型
 //  nFieldIndex  在SQL语句中字段的索引序号数据库字段的数据类型可以是数字型,日期型和字符型


 // GetValueFlaot函数
 // 得到数字型,日期型和字符型字段值函数
 // 参数:
 //  fVal   用来接收返回值(字段值)
 //  vIndex   数据库字段的名字或者索引,变体型,一般不直接用这个参数,
 //      应该用同形式的多态函数的参数调用
 //      数据库字段的数据类型要求是字型(int,long,float,货币型等)
 //  lpszFieldName 字段名,数据库字段的数据类型可以是数字型,日期型和字符型
 //  nFieldIndex  在SQL语句中字段的索引序号数据库字段的数据类型可以是数字型,日期型和字符型


 BOOL GetValueStr(char* cVal,_variant_t &vIndex,int


nFieldLen=-1);
 BOOL GetValueLong(long* lVal,_variant_t &vIndex);
 BOOL GetValueFloat(float* fVal,_variant_t &vIndex);


 BOOL GetValueStr(char* cVal,long lIndex,int nFieldLen=-1);
 BOOL GetValueLong(long* lVal,long lIndex);
 BOOL GetValueFloat(float* fVal,long lIndex);


 BOOL GetValueStr(char* cVal,CString strIndex,int nFieldLen=-1);
 GetValueLong(long *lVal, LPCSTR lpszIndex);
 BOOL GetValueFloat(float* fVal,CString strIndex);


 BOOL GetValueStr(CString& str,LPCSTR lpszFieldName,int nFieldLen=-1);
 BOOL GetValueStr(CString& str,UINT nFieldIndex,int nFieldLen=-1);
 BOOL GetValueStr(CString& str,_variant_t &vIndex,int nFieldLen=-1);


 // 判断值是否有效,是否为NULL
 BOOL VerifyVTData(_variant_t& value);
 BOOL VerifyVTData(char* pData);
protected:
 _RecordsetPtr* m_prsThis;
 _ConnectionPtr* m_pConn;
 void ReportError();


};


#endif // _BBADOCONNECT_H


 


 


 


////CPP文件


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


CBBAdoConnection::CBBAdoConnection()

   m_pConn=NULL;
}


_ConnectionPtr* CBBAdoConnection::GetConnection()
{
 return m_pConn;
}


CString CBBAdoConnection::GetConnString()
{
 return m_szConnString;
}


CBBAdoConnection::~CBBAdoConnection()
{
 // 关比连接
 CloseConnect();
}


BOOL CBBAdoConnection::OpenConnection(char *sConnString,BOOL bReOpen /*=FALSE*/)
{
 
 // 不需重新打开
 if(!bReOpen)
 {
  if(m_pConn !=NULL && ((*m_pConn)->State!=adStateClosed))
   return TRUE; 
 }


 VERIFY(sConnString);
 strcpy(m_szConnString,sConnString);


 try
 {
  m_pConn =new _ConnectionPtr;
  m_pConn->CreateInstance(__uuidof(Connection));
  if(m_pConn==NULL)
   return FALSE;
  HRESULT hr=(*m_pConn)->Open((char*)sConnString,"","",-1); 
  if(FAILED(hr))
   return FALSE; 
  return TRUE;
 }
 catch(_com_error)
 {
  ReportError(ErrFormOpenConnsction);
  return FALSE;
 }
 catch(...)
 {
  #ifdef _DEBUG // 调试时显示相应的错误信息
   MessageBox(NULL,"数据库连接未处理的异常!","连接失败",MB_OK|MB_ICONINFORMATION);
  #else
   MessageBox(NULL,"连接数据失败,请检查网络和数据库设置是否正确","连接失败",MB_OK|MB_ICONINFORMATION);
  #endif
  return FALSE;
 }
 SetConnTimeOut(5);
}


BOOL CBBAdoConnection::OpenRecordset(const char *sSQL, _RecordsetPtr *rs, char *sConnString)
{
 // rs=new _RecordsetPtr;
 VERIFY(sSQL);
 try
 { 


  if((m_pConn==NULL)||((*m_pConn)->State==adStateClosed))
  {
   int n=(*m_pConn)->State;
   if(sConnString!=NULL)
   {
    if(!OpenConnection(sConnString))
     return FALSE;
   }
   // 尝试连接数据库
   else
   {
    //
    // if(!OpenConnection(m_szConnString))
    // return FALSE;
    // MessageBox(NULL,"数据库连接已经断开,请重新连接!","连接问题",MB_OK|MB_ICONINFORMATION); 
   }


   return FALSE;
  } 
  // rs=new _RecordsetPtr;
  HRESULT hr;
  hr=rs->CreateInstance(__uuidof(Recordset));
  if(FAILED(hr))
  {  
   return FALSE;// 建立实例失败
  }    
  hr=(*rs)->Open(sSQL,m_pConn->GetInterfacePtr(),
   adOpenStatic, adLockBatchOptimistic, -1);
  if(FAILED(hr))
  {  
   return FALSE;// 打开连接失败
  }  
  return TRUE;// 成功返回
 }
 catch(_com_error)
 {
 
  // AfxMessageBox(ce->Description());
  ReportError(ErrFromOpenRecordset);
  return FALSE;
 }
 catch(...)
 {
  MessageBox(NULL,"数据库记录打开失败!","记录失败",MB_OK|MB_ICONINFORMATION);
  return FALSE;
 }
 return TRUE;
}


void CBBAdoConnection::CloseConnect()
{
 try
 {
  if(m_pConn!=NULL)
  {
   if((*m_pConn)->State!=adStateClosed)
    (*m_pConn)->Close();  
   delete m_pConn;
   m_pConn=NULL;
  }
 }
 catch(_com_error)
 {
  ReportError(ErrFormCloseConnection);
 }
 catch(...)
 {
  AfxMessageBox("关闭数据库连接未知错误!");
 }
}


 


 


BOOL CBBAdoConnection::OpenConnection(CString strConnString, BOOL bReOpen)
{
 char c[512];
 strcpy(c,strConnString.GetBuffer(0));
 strConnString.ReleaseBuffer();
 return OpenConnection(c,bReOpen);
}


BOOL CBBAdoConnection::OpenRecordset(CString strSQL, _RecordsetPtr *rs, CString sConnString)
{
 char c[1024];
 strcpy(c,strSQL.GetBuffer(0));
 strSQL.ReleaseBuffer();
 return OpenRecordset(c,rs,(char*)(LPCTSTR)sConnString);
}


BOOL CBBAdoConnection::ExecuteTrans(CStringArray arrStrSQL) // 开始事务处理,不返回任何记录集,参数为事务SQL数组
{
 
 (*m_pConn)->BeginTrans();


 try
 {
  _RecordsetPtr* prsThis;
  for(int i=0;i<arrStrSQL.GetSize();i++)
  {
   prsThis=new _RecordsetPtr;  
   OpenRecordset(arrStrSQL.ElementAt(i),prsThis);
   delete prsThis;
  }
  prsThis=NULL;
  (*m_pConn)->CommitTrans();
  return TRUE;
 }
 catch(_com_error)
 {
  (*m_pConn)->RollbackTrans();
  ReportError(ErrFormTanslation);
  return FALSE;
 }
}


 



// 执行SQL操作,不返回记录集
int CBBAdoConnection::ExecuteSQL(LPCSTR szSQL)
{
 // VARIANT vEffect;
 try
 {
  (*m_pConn)->Execute(szSQL,NULL,adCmdText|adExecuteNoRecords);
  return TRUE;
 }
 catch(_com_error)
 {
  ReportError(ErrFormTanslation);   
  return FALSE;
 }
 // return vEffect.lVal;
}


// 返回是否处在连接状态
BOOL CBBAdoConnection::IsConnectClose()
{


 return (m_pConn==NULL)||((*m_pConn)->State==adStateClosed);
}


// 设置连接超时
int CBBAdoConnection::SetConnTimeOut(long lTimeOut)
{
 return (*m_pConn)->put_ConnectionTimeout(lTimeOut);
}


int CBBAdoConnection::SetCommTimeOut(long lTimeOut)
{
 return (*m_pConn)->put_CommandTimeout(lTimeOut);
}


// 报告错误
void CBBAdoConnection::ReportError(int nERRORfrom)
{
 switch(nERRORfrom)
 {
 case ErrFormOpenConnsction:
  #ifdef _DEBUG  // 调试试时显示相应的错误信息
   try
   {
    for(long l=0;l<(*m_pConn)->Errors->Count;l++)
    {
     ErrorPtr pErr;
     pErr=(*m_pConn)->Errors->GetItem(l);
     CString str;
     str=(char*)pErr->Description;    
     MessageBox(NULL,str,"连接失败",MB_OK|MB_ICONINFORMATION);
    }
   }
   catch(...)
   {
    MessageBox(NULL,"数据库连接未知错误,无法捕捉具体错误信息!","错误",MB_ICONINFORMATION);
   }
  #else
    MessageBox(NULL,"连接数据失败,请检查网络和数据库设置是否正确","连接失败",MB_OK|MB_ICONINFORMATION);
  #endif
  break;
 case ErrFromOpenRecordset:
  #ifdef _DEBUG
    try
    {   
     for(long i=0;i<(*m_pConn)->Errors->Count;i++)
     {
      ErrorPtr pErr;
      pErr=(*m_pConn)->Errors->GetItem(i);
      AfxMessageBox(pErr->Description);
     }
    }
    catch(...)
    {
     MessageBox(NULL,"数据库连接未知错误,无法捕捉具体错误信息!","错误",MB_ICONINFORMATION);
    }
  #else
    MessageBox(NULL,"打开数据库失败,请检查网络,并尝试重新连接数据库!","记录失败",MB_OK|MB_ICONINFORMATION);
  #endif
  break;
 case ErrFormCloseConnection:
  #ifdef _DEBUG  // 调试时显示相应的错误信息
   try
   {
    for(long l=0;l<(*m_pConn)->Errors->Count;l++)
    {
     ErrorPtr pErr;
     pErr=(*m_pConn)->Errors->GetItem(l);
     CString str;
     str=(char*)pErr->Description;
     MessageBox(NULL,str,"连接失败",MB_OK|MB_ICONINFORMATION);
    }
   }
   catch(...)
   {
    MessageBox(NULL,"数据库连接未知错误,无法捕捉具体错误信息!","错误",MB_ICONINFORMATION);
   }


  #else
    ;// MessageBox(NULL,"关闭数据库连接异常","关闭异常",MB_OK|MB_ICONINFORMATION);
  #endif
  break;
 case ErrFormTanslation:
  #if def _DEBUG
   try
   {
    for(long i=0;i<(*m_pConn)->Errors->Count;i++)
    {
     ErrorPtr pErr;
     pErr=(*m_pConn)->Errors->GetItem(i);
     AfxMessageBox(pErr->Description);
    }
   }
   catch(...)
   {
    MessageBox(NULL,"数据库连接未知错误,无法捕捉具体错误信息!","错误",MB_ICONINFORMATION);
   }
  #else
    MessageBox(NULL,"数据库执行任务失败,请检查数据库。","任务失败",MB_OK|MB_ICONINFORMATION);
  #endif
  break;
 default:
  break;
 }
}


 


 


/////////////// CRecordsetValus



CBBRstValues::CBBRstValues()
{
 ;
}


CBBRstValues::CBBRstValues(_ConnectionPtr* pConn,_RecordsetPtr* pRs)
{
 ASSERT(pConn);
 ASSERT(pRs);
 m_prsThis=pRs;
 m_pConn=pConn;
}


CBBRstValues::CBBRstValues(CBBAdoConnection* pBBadoConn,_RecordsetPtr* pRs)
{
 CBBRstValues(pBBadoConn->GetConnection(),pRs);
}


CBBRstValues::~CBBRstValues()
{
 ;
}


void CBBRstValues::InitConnectAndRst(_ConnectionPtr *pConn, _RecordsetPtr *pRs)
{
 ASSERT(pConn);
 ASSERT(pRs);
 m_prsThis=pRs;
 m_pConn=pConn;
}


void CBBRstValues::InitConnectAndRst(CBBAdoConnection *pBBAdoConn, _RecordsetPtr *pRs)
{
 InitConnectAndRst(pBBAdoConn->GetConnection(),pRs);
}


BOOL CBBRstValues::GetValueLong(long *lVal, _variant_t &vIndex)
{
 _variant_t value;
 try{


  if((*m_prsThis)==NULL||(*m_prsThis)->State==adStateClosed) 
  {


#ifdef _DEBUG
   AfxMessageBox("记录集未打开!");
#else
   MessageBox(NULL,"无法读取数据库资料,可能数据库连接已经断开,请重新连接、然后重试。","连接问题",MB_ICONINFORMATION);
#endif
   return FALSE;
  }


  if((*m_prsThis)->adoEOF)
  {
   lVal=0;
   return FALSE;
  }


  value=(*m_prsThis)->GetCollect(vIndex); 
 }
 catch(_com_error)
 {
  ReportError();
  return FALSE;
 }
 catch(...)
 {
  AfxMessageBox("数据库字段访问未知错误!请检查数据库是否改动。",MB_ICONINFORMATION);
  return FALSE;
 }


 if(VerifyVTData(value)) 
 {
  *lVal = long(value);
 }
 else
 {
  *lVal=0;
 }


 return TRUE;
}


BOOL CBBRstValues::GetValueStr(char *cVal, _variant_t &vIndex, int nFieldLen)
{
 char * c=NULL;
 _variant_t value;
 DATE dt;
 CString str;
 COleDateTime da;
 
 // 检查是数组
 // VERIFY(sizeof(cVal)<1);
 
memset(cVal,0,sizeof(cVal));
 try
 {
  if((*m_prsThis)==NULL||(*m_prsThis)->State==adStateClosed)
  {
#ifdef _DEBUG
   AfxMessageBox("记录集未打开!");
#else
   MessageBox(NULL,"无法读取数据库资料,可能数据库连接已经断开,请重新连接、然后重试。","连接问题",MB_ICONINFORMATION);
#endif
   return FALSE;
  }


  if((*m_prsThis)->adoEOF)
  {
   cVal[0]='/0';
   return FALSE;
  }
  value = (*m_prsThis)->GetCollect(vIndex);
 }
 catch(_com_error)
 {
  ReportError();
  // AfxMessageBox("数据库字段访问错误!");
 
return FALSE;
 }
 catch(...)
 {
  AfxMessageBox("数据库字段访问未知错误!请检查数据库是否改动。",MB_ICONINFORMATION);
  return FALSE;
 }
 
 if(VerifyVTData(value))
 {
  switch(value.vt)
  {
   case VT_BSTR:
    c = (char *)_com_util::ConvertBSTRToString( V_BSTR(&value) );
    if(VerifyVTData(c))
    {          
     if(nFieldLen<=0)
     {
      strcpy(cVal,(char*)c);
     }
     else
     {
      strncpy(cVal, (char*)c, nFieldLen);
     }   
    }
    delete c;
    c=NULL;
    break;
   case VT_I4:
   case VT_DECIMAL: 
   case VT_UI4:
   case VT_I8:
   case VT_UI8:
   case VT_INT:
   case VT_UINT:
    long lVal;
    lVal = long(value);
    ltoa(lVal,cVal,10);   
    break;
   case VT_DATE:   
    dt=value.date;
    da=COleDateTime(dt);   
    // str=da.Format("%Y-%m-%d %H:%M:%S");
    str=da.Format("%Y-%m-%d ");
    c=new char[64];
    memset(c,0,sizeof(char)*64);
    strcpy(c,str.GetBuffer(0));
    str.ReleaseBuffer();
    if(VerifyVTData(c))
    {          
     if(nFieldLen<=0)
     {
      strcpy(cVal,(char*)c);
     }
     else
     {
      strncpy(cVal, (char*)c, nFieldLen);
      cVal[nFieldLen]='/0';
     }   
    }
    delete c;
    c=NULL;
    break;
   default:
#ifdef _DEBUG
    AfxMessageBox("未处理的字段数据类型,请处理!");
#else
    break;
#endif
    break;
  }
 }


 else
 {
  cVal[0]='/0';
 }
 return TRUE;
}


BOOL CBBRstValues::GetValueLong(long *lVal, long lIndex)
{
 _variant_t vIndex(lIndex);
 return GetValueLong(lVal,vIndex);
}


BOOL CBBRstValues::GetValueLong(long *lVal, LPCSTR lpszIndex)
{
 _variant_t vIndex(lpszIndex);
 return GetValueLong(lVal,vIndex);
}


BOOL CBBRstValues::VerifyVTData(char *pData)
{
 if(pData == NULL)
 {
  return FALSE;
 }
 return TRUE;
}


BOOL CBBRstValues::VerifyVTData(_variant_t &value)
{
 if(value.vt == VT_NULL)
 {
  return FALSE;
 }
 return TRUE;
}


BOOL CBBRstValues::GetValueStr(CString& str,LPCSTR lpszFieldName,int nFieldLen/*=-1*/)
{
 _variant_t vIndex(lpszFieldName);
 return GetValueStr(str,vIndex,nFieldLen);
}


BOOL CBBRstValues::GetValueStr(CString& str,UINT nFieldIndex,int nFieldLen/*=-1*/)
{
 _variant_t vIndex((long)nFieldIndex); 
 return GetValueStr(str,vIndex,nFieldLen);
 
}


BOOL CBBRstValues::GetValueStr(CString& str,_variant_t &vIndex,int nFieldLen/*=-1*/)
{
 TCHAR buffer[1024];
 if(nFieldLen > 1023)
  nFieldLen = 1023;
 
 BOOL bResult=GetValueStr((char*)buffer,vIndex,nFieldLen);
 str.Format(buffer);
 str.TrimRight();
 return bResult;
}


BOOL CBBRstValues::GetValueFloat(float* fVal,_variant_t &vIndex)
{
 _variant_t value;
 try
 {
  if((*m_prsThis)==NULL||(*m_prsThis)->State==adStateClosed)
  {
 
#ifdef _DEBUG
   AfxMessageBox("记录集未打开!");
#else
   MessageBox(NULL,"无法读取数据库资料,可能数据库连接已经断开,请重新连接、然后重试。","连接问题",MB_ICONINFORMATION);
#endif
   return FALSE;
  }
 
  if((*m_prsThis)->adoEOF)
  {
   fVal=0;
   return FALSE;
  }


  value=(*m_prsThis)->GetCollect(vIndex);  
 }
 catch(_com_error)
 { 
  ReportError();
  return FALSE;
 }
 catch(...)
 {
  AfxMessageBox("数据库字段访问未知错误!请检查连接数据库结构是否已经更改。",MB_ICONINFORMATION);
  return FALSE;
 }


 if(VerifyVTData(value))
 {
  *fVal = float(value);
 }
 else
 {
  *fVal = 0;
 }
 return TRUE;
}



BOOL CBBRstValues::GetValueFloat(float* fVal,long lIndex)
{
 _variant_t vIndex(lIndex);
 return GetValueFloat(fVal,vIndex);
}


BOOL CBBRstValues::GetValueFloat(float* fVal,CString  strIndex)
{
 _variant_t vIndex(strIndex);
 return GetValueFloat(fVal,vIndex);
}


BOOL CBBRstValues::GetValueStr(char *cVal,long lIndex,int nFieldLen)
{
 _variant_t vIndex;
 vIndex=_variant_t(lIndex);
 return GetValueStr(cVal,vIndex);
}



BOOL CBBRstValues::GetValueStr(char *cVal,CString strIndex,int nFieldLen)
{
 _variant_t vIndex;
 vIndex=_variant_t(strIndex);
 return GetValueStr(cVal,vIndex);
}



void CBBRstValues::ReportError()
{
#ifdef _DEBUG
 try
 {
  for(long l=0;l<(*m_pConn)->Errors->Count;l++)
  {
   ErrorPtr pErr;
   pErr=(*m_pConn)->Errors->GetItem(l);
   AfxMessageBox(pErr->Description);
  } 
 }
 catch(...)
 {
  AfxMessageBox("字段错误对象访问错误,请检查书写是否正确。");
 }
#else
 MessageBox(NULL,"字段访问发生错误,请确认数据库结构没有改动。","字段访问",MB_ICONINFORMATION);
#endif
 // AfxMessageBox("数据库字段访问错误!");
}


BOOL CBBRstValues::GetValText(CString &strText, CString &strFieldName)
{
 _bstr_t varChunk;
 _bstr_t varNotes;
 long lngTotalsize,
       lngOffSet = 0,
       lngChunkSize = 100;
 _variant_t vFieldName = _variant_t(strFieldName);
 lngTotalsize = (*m_prsThis)->Fields->Item[vFieldName]->ActualSize/2;
 if (lngTotalsize <= 0)
  return FALSE;


 try
 {
  while (lngOffSet < lngTotalsize)
  {
   varChunk = (*m_prsThis)->Fields->Item[vFieldName]->GetChunk(lngChunkSize);
   varNotes = varNotes + varChunk;
   lngOffSet = lngOffSet + lngChunkSize;
  }
  strText=(char*)varNotes;
 }
 catch(_com_error)
 {
  ReportError();
  return FALSE;
 }
 catch(...)
 {


#ifdef _DEBUG
  AfxMessageBox("获取Text字段未知错误");
#endif
  return FALSE;
 }


 return TRUE;
}


 


// 上面代码,还有没有完善的地方,更完善的代码,在以后会发表,现在我已经做成了一个DLL,并而还有一些示例文件,需要DLL和示例文件的,请与我联系。EMail: seesi@163.com


 


更多文章在我的个人主页:seesi.51.net


 


 

0 0

相关博文

我的热门文章

img
取 消
img