|
对于初学者，使用ADO访问数据库的时候，涉及到各种数据类型转换，可能有一些难度，我试图封装了ADO访问数据库，使其更方便的用现有的VC的数据类型，更加方便的使用ADO操作数据库。
下面分别提供两个封装ADO数据库访问的类，一个是数据库的连接类，一个是数据库字段访问的类。
在连接类中，大家可以看到，连接类中并没有Recordset的成员变量，因为这样的，在整个数据库应用程序中，数据库的连接一般一个就够了，而同时打开的Reocordset则可能不只一个，所以，如果两个在同一个类里，那么，如果要同时打开两个记录集，需要建立类的两个实例，就是需要同时打开两个数据库连接，如果对于连接的是同一个数据库，同时打开两个连接的话，意味着资源的不必要的浪费。
数据库字段访问类，简化了，获取数据库字段内容的操作，避免了数据类型转换的麻烦。
两个类都对错误处理进行了较多的考虑，在访问数据库中，如果没有错误处理，其害处是显而易见的。
#ifndef _BBADOCONNECT_H
#define _BBADOCONNECT_H
//
// ADO访问数据库类
// 软件环境：需要MSADO15.DLL
// 作者：邓振波
// 2001.4.20
// Email：bozi@china.com
// 说明：封装了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: bozi@china.com
|
