VC中用ADO如何得到已知表的所有字段类型？？
[问题点数：100分，结帖人LLSS666]
VC中用ADO如何得到已知表的所有字段类型？？
[问题点数：100分，结帖人LLSS666]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
匿名用户不能发表回复！|VC++&ADO2数据类源文件
************************************Ado2.h*********************************************
// MODULE: Ado2.h
// AUTHOR: Carlos Antollini
// Copyright (c) . All Rights Reserved.
// Date: August 01, 2005
// Version 2.20
// This code may be used in compiled form in any way you
desire. This
// file may be redistributed unmodified by any means PROVIDING
// not sold for profit without the authors written consent,
// providing that this notice and the authors name and all
copyright&
// notices remains intact.&
// An email letting me know how you are using it would be nice
// This file is provided "as is" with no expressed or implied
// The author accepts no liability for any damage/loss of
business that
// this product may cause.
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_ADO2_H_INCLUDED_)
#define AFX_ADO2_H_INCLUDED_
#if _MSC_VER &= 1000
#pragma once
#endif // _MSC_VER &= 1000
#pragma warning (disable: 4146)
// CG : In order to use this code against a different version
of ADO, the appropriate
// ADO library needs to be used in the #import statement
#pragma message ("Make sure you go to
Tools.Options.Directories.Library files and add the paths to
msado15.dll and msjro.dll will usually be in C:\\Program
Files\\Common Files\\System\\ado")
//#import "C:\Program Files\Common
Files\System\ado\msado15.dll" rename("EOF", "EndOfFile")
//#import "C:\Program Files\Common Files\System\ado\MSJRO.DLL"
no_namespace rename("ReplicaTypeEnum",
"_ReplicaTypeEnum")&
#import rename("EOF", "EndOfFile")
#import no_namespace rename("ReplicaTypeEnum",
"_ReplicaTypeEnum")&
using namespace ADODB;
#pragma warning (default: 4146)
#include "icrsint.h"
class CADOC
struct CADOFieldInfo
char m_strName[30];&
short m_nT
long m_lS&
long m_lDefinedS
short m_nOrdinalP
BOOL m_bR &&
BOOL m_bAllowZeroL&
long m_lCollatingO &
CString IntToStr(int nVal);
CString LongToStr(long lVal);
CString ULongToStr(unsigned long ulVal);
CString DblToStr(double dblVal, int ndigits = 20);
CString DblToStr(float fltVal);
class CJetEngine
CJetEngine()
virtual ~CJetEngine()
static BOOL CompactDatabase(CString strDatabaseSource, CString
strDatabaseDestination);
static BOOL RefreshCache(ADODB::_Connection *pconn);
class CADODatabase
enum cadoConnectModeEnum
connectModeUnknown = adModeUnknown,
connectModeRead = adModeRead,
connectModeWrite = adModeWrite,
connectModeReadWrite = adModeReadWrite,
connectModeShareDenyRead = adModeShareDenyRead,
connectModeShareDenyWrite = adModeShareDenyWrite,
connectModeShareExclusive = adModeShareExclusive,
connectModeShareDenyNone = adModeShareDenyNone
CADODatabase()
::CoInitialize(NULL);
m_pConnection = NULL;
m_strConnection = _T("");
m_strLastError = _T("");
m_dwLastError = 0;
m_pConnection.CreateInstance(__uuidof(Connection));
m_nRecordsAffected = 0;
m_nConnectionTimeout = 0;
virtual ~CADODatabase()
m_pConnection.Release();
m_pConnection = NULL;
m_strConnection = _T("");
m_strLastError = _T("");
m_dwLastError = 0;
::CoUninitialize();
BOOL Open(LPCTSTR lpstrConnection = _T(""), LPCTSTR
lpstrUserID = _T(""), LPCTSTR lpstrPassword = _T(""));
_ConnectionPtr GetActiveConnection()&
{return m_pC};
BOOL Execute(LPCTSTR lpstrExec);
int GetRecordsAffected()
{return m_nRecordsA};
DWORD GetRecordCount(_RecordsetPtr m_pRs);
long BeginTransaction()&
{return m_pConnection-&BeginTrans();};
long CommitTransaction()&
{return m_pConnection-&CommitTrans();};
long RollbackTransaction()&
{return m_pConnection-&RollbackTrans();};
BOOL IsOpen();
void Close();
void SetConnectionMode(cadoConnectModeEnum nMode)
{m_pConnection-&PutMode((enum
ConnectModeEnum)nMode);};
void SetConnectionString(LPCTSTR lpstrConnection)
{m_strConnection = lpstrC};
CString GetConnectionString()
{return m_strC};
CString GetLastErrorString()&
{return m_strLastE};
DWORD GetLastError()
{return m_dwLastE};
CString GetErrorDescription()&
{return m_strErrorD};
void SetConnectionTimeout(long nConnectionTimeout = 30)
{m_nConnectionTimeout = nConnectionT};
protected:
void dump_com_error(_com_error &e);
_ConnectionPtr m_pC
protected:
CString m_strC
CString m_strLastE
CString m_strErrorD
DWORD m_dwLastE
int m_nRecordsA
long m_nConnectionT
class CADORecordset
BOOL Clone(CADORecordset& pRs);
enum cadoOpenEnum
openUnknown = 0,
openQuery = 1,
openTable = 2,
openStoredProc = 3
enum cadoEditEnum
dbEditNone = 0,
dbEditNew = 1,
dbEdit = 2
enum cadoPositionEnum
positionUnknown = -1,
positionBOF = -2,
positionEOF = -3
enum cadoSearchEnum
searchForward = 1,
searchBackward = -1
enum cadoDataType
typeEmpty = ADODB::adEmpty,
typeTinyInt = ADODB::adTinyInt,
typeSmallInt = ADODB::adSmallInt,
typeInteger = ADODB::adInteger,
typeBigInt = ADODB::adBigInt,
typeUnsignedTinyInt = ADODB::adUnsignedTinyInt,
typeUnsignedSmallInt = ADODB::adUnsignedSmallInt,
typeUnsignedInt = ADODB::adUnsignedInt,
typeUnsignedBigInt = ADODB::adUnsignedBigInt,
typeSingle = ADODB::adSingle,
typeDouble = ADODB::adDouble,
typeCurrency = ADODB::adCurrency,
typeDecimal = ADODB::adDecimal,
typeNumeric = ADODB::adNumeric,
typeBoolean = ADODB::adBoolean,
typeError = ADODB::adError,
typeUserDefined = ADODB::adUserDefined,
typeVariant = ADODB::adVariant,
typeIDispatch = ADODB::adIDispatch,
typeIUnknown = ADODB::adIUnknown,
typeGUID = ADODB::adGUID,
typeDate = ADODB::adDate,
typeDBDate = ADODB::adDBDate,
typeDBTime = ADODB::adDBTime,
typeDBTimeStamp = ADODB::adDBTimeStamp,
typeBSTR = ADODB::adBSTR,
typeChar = ADODB::adChar,
typeVarChar = ADODB::adVarChar,
typeLongVarChar = ADODB::adLongVarChar,
typeWChar = ADODB::adWChar,
typeVarWChar = ADODB::adVarWChar,
typeLongVarWChar = ADODB::adLongVarWChar,
typeBinary = ADODB::adBinary,
typeVarBinary = ADODB::adVarBinary,
typeLongVarBinary = ADODB::adLongVarBinary,
typeChapter = ADODB::adChapter,
typeFileTime = ADODB::adFileTime,
typePropVariant = ADODB::adPropVariant,
typeVarNumeric = ADODB::adVarNumeric,
typeArray = ADODB::adVariant
enum cadoSchemaType&
schemaSpecific = adSchemaProviderSpecific,
schemaAsserts = adSchemaAsserts,
schemaCatalog = adSchemaCatalogs,
schemaCharacterSet = adSchemaCharacterSets,
schemaCollections = adSchemaCollations,
schemaColumns = adSchemaColumns,
schemaConstraints = adSchemaCheckConstraints,
schemaConstraintColumnUsage =
adSchemaConstraintColumnUsage,
schemaConstraintTableUsage &=
adSchemaConstraintTableUsage,
shemaKeyColumnUsage = adSchemaKeyColumnUsage,
schemaTableConstraints = adSchemaTableConstraints,
schemaColumnsDomainUsage = adSchemaColumnsDomainUsage,
schemaIndexes = adSchemaIndexes,
schemaColumnPrivileges = adSchemaColumnPrivileges,
schemaTablePrivileges = adSchemaTablePrivileges,
schemaUsagePrivileges = adSchemaUsagePrivileges,
schemaProcedures = adSchemaProcedures,
schemaTables = adSchemaTables,
schemaProviderTypes = adSchemaProviderTypes,
schemaViews = adSchemaViews,
schemaViewTableUsage = adSchemaViewTableUsage,
schemaProcedureParameters = adSchemaProcedureParameters,
schemaForeignKeys = adSchemaForeignKeys,
schemaPrimaryKeys = adSchemaPrimaryKeys,
schemaProcedureColumns = adSchemaProcedureColumns,
schemaDBInfoKeywords = adSchemaDBInfoKeywords,
schemaDBInfoLiterals = adSchemaDBInfoLiterals,
schemaCubes = adSchemaCubes,
schemaDimensions = adSchemaDimensions,
schemaHierarchies &=
adSchemaHierarchies,&
schemaLevels = adSchemaLevels,
schemaMeasures = adSchemaMeasures,
schemaProperties = adSchemaProperties,
schemaMembers = adSchemaMembers,
BOOL SetFieldValue(int nIndex, int nValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, int nValue);
BOOL SetFieldValue(int nIndex, long lValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, long lValue);
BOOL SetFieldValue(int nIndex, unsigned long lValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, unsigned long
BOOL SetFieldValue(int nIndex, double dblValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, double
dblValue);
BOOL SetFieldValue(int nIndex, CString strValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, CString
strValue);
BOOL SetFieldValue(int nIndex, COleDateTime time);
BOOL SetFieldValue(LPCTSTR lpFieldName, COleDateTime
BOOL SetFieldValue(int nIndex, bool bValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, bool bValue);
BOOL SetFieldValue(int nIndex, COleCurrency cyValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, COleCurrency
BOOL SetFieldValue(int nIndex, _variant_t vtValue);
BOOL SetFieldValue(LPCTSTR lpFieldName, _variant_t
BOOL SetFieldEmpty(int nIndex);
BOOL SetFieldEmpty(LPCTSTR lpFieldName);
void CancelUpdate();
BOOL Update();
void Edit();
BOOL AddNew();
BOOL AddNew(CADORecordBinding &pAdoRecordBinding);
BOOL Find(LPCTSTR lpFind, int nSearchDirection =
CADORecordset::searchForward);
BOOL FindFirst(LPCTSTR lpFind);
BOOL FindNext();
CADORecordset();
CADORecordset(CADODatabase* pAdoDatabase);
virtual ~CADORecordset()
if(m_pRecordset)
m_pRecordset.Release();
if(m_pCmd)
m_pCmd.Release();
m_pRecordset = NULL;
m_pCmd = NULL;
m_pRecBinding = NULL;
m_strQuery = _T("");
m_strLastError = _T("");
m_dwLastError = 0;
m_nEditStatus = dbEditN
CString GetQuery()&
{return m_strQ};
void SetQuery(LPCSTR strQuery)&
{m_strQuery = strQ};
BOOL RecordBinding(CADORecordBinding
&pAdoRecordBinding);
DWORD GetRecordCount();
BOOL IsOpen();
void Close();
BOOL Open(_ConnectionPtr mpdb, LPCTSTR lpstrExec = _T(""), int
nOption = CADORecordset::openUnknown);
BOOL Open(LPCTSTR lpstrExec = _T(""), int nOption =
CADORecordset::openUnknown);
BOOL OpenSchema(int nSchema, LPCTSTR SchemaID = _T(""));
long GetFieldCount()
{return m_pRecordset-&Fields-&GetCount();};
BOOL GetFieldValue(LPCTSTR lpFieldName, int&
BOOL GetFieldValue(int nIndex, int& nValue);
BOOL GetFieldValue(LPCTSTR lpFieldName, long&
BOOL GetFieldValue(int nIndex, long& lValue);
BOOL GetFieldValue(LPCTSTR lpFieldName, unsigned long&
BOOL GetFieldValue(int nIndex, unsigned long&
BOOL GetFieldValue(LPCTSTR lpFieldName, double&
BOOL GetFieldValue(int nIndex, double& dbValue);
BOOL GetFieldValue(LPCTSTR lpFieldName, CString& strValue,
CString strDateFormat = _T(""));
BOOL GetFieldValue(int nIndex, CString& strValue, CString
strDateFormat = _T(""));
BOOL GetFieldValue(LPCTSTR lpFieldName, COleDateTime&
BOOL GetFieldValue(int nIndex, COleDateTime& time);
BOOL GetFieldValue(int nIndex, bool& bValue);
BOOL GetFieldValue(LPCTSTR lpFieldName, bool&
BOOL GetFieldValue(int nIndex, COleCurrency&
BOOL GetFieldValue(LPCTSTR lpFieldName, COleCurrency&
BOOL GetFieldValue(int nIndex, _variant_t& vtValue);
BOOL GetFieldValue(LPCTSTR lpFieldName, _variant_t&
BOOL IsFieldNull(LPCTSTR lpFieldName);
BOOL IsFieldNull(int nIndex);
BOOL IsFieldEmpty(LPCTSTR lpFieldName);
BOOL IsFieldEmpty(int nIndex);
BOOL IsEof()
{return m_pRecordset-&EndOfFile == VARIANT_TRUE;};
BOOL IsEOF()
{return m_pRecordset-&EndOfFile == VARIANT_TRUE;};
BOOL IsBof()
{return m_pRecordset-&BOF == VARIANT_TRUE;};
BOOL IsBOF()
{return m_pRecordset-&BOF == VARIANT_TRUE;};
void MoveFirst()&
{m_pRecordset-&MoveFirst();};
void MoveNext()&
{m_pRecordset-&MoveNext();};
void MovePrevious()&
{m_pRecordset-&MovePrevious();};
void MoveLast()&
{m_pRecordset-&MoveLast();};
long GetAbsolutePage()
{return m_pRecordset-&GetAbsolutePage();};
void SetAbsolutePage(int nPage)
{m_pRecordset-&PutAbsolutePage((enum
PositionEnum)nPage);};
long GetPageCount()
{return m_pRecordset-&GetPageCount();};
long GetPageSize()
{return m_pRecordset-&GetPageSize();};
void SetPageSize(int nSize)
{m_pRecordset-&PutPageSize(nSize);};
long GetAbsolutePosition()
{return m_pRecordset-&GetAbsolutePosition();};
void SetAbsolutePosition(int nPosition)
{m_pRecordset-&PutAbsolutePosition((enum
PositionEnum)nPosition);};
BOOL GetFieldInfo(LPCTSTR lpFieldName, CADOFieldInfo*
BOOL GetFieldInfo(int nIndex, CADOFieldInfo* fldInfo);
BOOL AppendChunk(LPCTSTR lpFieldName, LPVOID lpData, UINT
BOOL AppendChunk(int nIndex, LPVOID lpData, UINT
BOOL GetChunk(LPCTSTR lpFieldName, CString&
strValue);
BOOL GetChunk(int nIndex, CString& strValue);
BOOL GetChunk(LPCTSTR lpFieldName, LPVOID pData);
BOOL GetChunk(int nIndex, LPVOID pData);
CString GetString(LPCTSTR lpCols, LPCTSTR lpRows, LPCTSTR
lpNull, long numRows = 0);
CString GetLastErrorString()&
{return m_strLastE};
DWORD GetLastError()
{return m_dwLastE};
void GetBookmark()
{m_varBookmark = m_pRecordset-&B};
BOOL SetBookmark();
BOOL Delete();
BOOL IsConnectionOpen()
{return m_pConnection != NULL &&
m_pConnection-&GetState() != adStateC};
_RecordsetPtr GetRecordset()
{return m_pR};
_ConnectionPtr GetActiveConnection()&
{return m_pC};
BOOL SetFilter(LPCTSTR strFilter);
BOOL SetSort(LPCTSTR lpstrCriteria);
BOOL SaveAsXML(LPCTSTR lpstrXMLFile);
BOOL OpenXML(LPCTSTR lpstrXMLFile);
BOOL Execute(CADOCommand* pCommand);
BOOL Requery();
_RecordsetPtr m_pR
_CommandPtr m_pC
protected:
_ConnectionPtr m_pC
int m_nSearchD
CString m_strF
_variant_t m_varBookF
_variant_t m_varB
int m_nEditS
CString m_strLastE
DWORD m_dwLastE
void dump_com_error(_com_error &e);
IADORecordBinding *m_pRecB
CString m_strQ
protected:
BOOL PutFieldValue(LPCTSTR lpFieldName, _variant_t
BOOL PutFieldValue(_variant_t vtIndex, _variant_t
BOOL GetFieldInfo(FieldPtr pField, CADOFieldInfo*
BOOL GetChunk(FieldPtr pField, CString& strValue);
BOOL GetChunk(FieldPtr pField, LPVOID lpData);
BOOL AppendChunk(FieldPtr pField, LPVOID lpData, UINT
class CADOParameter
enum cadoParameterDirection
paramUnknown = adParamUnknown,
paramInput = adParamInput,
paramOutput = adParamOutput,
paramInputOutput = adParamInputOutput,
paramReturnValue = adParamReturnValue&
CADOParameter(int nType, long lSize = 0, int nDirection =
paramInput, CString strName = _T(""));
virtual ~CADOParameter()
m_pParameter.Release();
m_pParameter = NULL;
m_strName = _T("");
BOOL SetValue(int nValue);
BOOL SetValue(long lValue);
BOOL SetValue(double dbValue);
BOOL SetValue(CString strValue);
BOOL SetValue(COleDateTime time);
BOOL SetValue(_variant_t vtValue);
BOOL GetValue(int& nValue);
BOOL GetValue(long& lValue);
BOOL GetValue(double& dbValue);
BOOL GetValue(CString& strValue, CString strDateFormat =
BOOL GetValue(COleDateTime& time);
BOOL GetValue(_variant_t& vtValue);
void SetPrecision(int nPrecision)
{m_pParameter-&PutPrecision(nPrecision);};
void SetScale(int nScale)
{m_pParameter-&PutNumericScale(nScale);};
void SetName(CString strName)
{m_strName = strN};
CString GetName()
{return m_strN};
int GetType()
{return m_nT};
_ParameterPtr GetParameter()
{return m_pP};
protected:
void dump_com_error(_com_error &e);
protected:
_ParameterPtr m_pP
CString m_strN
CString m_strLastE
DWORD m_dwLastE
class CADOCommand
enum cadoCommandType
typeCmdText = adCmdText,
typeCmdTable = adCmdTable,
typeCmdTableDirect = adCmdTableDirect,
typeCmdStoredProc = adCmdStoredProc,
typeCmdUnknown = adCmdUnknown,
typeCmdFile = adCmdFile
CADOCommand(CADODatabase* pAdoDatabase, CString strCommandText
= _T(""), int nCommandType = typeCmdStoredProc);
virtual ~CADOCommand()
::SysFreeString(m_pCommand-&CommandText);
m_pCommand.Release();
m_pCommand = NULL;
m_strCommandText = _T("");
void SetTimeout(long nTimeOut)
{m_pCommand-&PutCommandTimeout(nTimeOut);};
void SetText(CString strCommandText);
void SetType(int nCommandType);
int GetType()
{return m_nCommandT};
BOOL AddParameter(CADOParameter* pAdoParameter);
BOOL AddParameter(CString strName, int nType, int nDirection,
long lSize, int nValue);
BOOL AddParameter(CString strName, int nType, int nDirection,
long lSize, long lValue);
BOOL AddParameter(CString strName, int nType, int nDirection,
long lSize, double dblValue, int nPrecision = 0, int nScale =
BOOL AddParameter(CString strName, int nType, int nDirection,
long lSize, CString strValue);
BOOL AddParameter(CString strName, int nType, int nDirection,
long lSize, COleDateTime time);
BOOL AddParameter(CString strName, int nType, int nDirection,
long lSize, _variant_t vtValue, int nPrecision = 0, int nScale =
CString GetText()
{return m_strCommandT};
BOOL Execute(int nCommandType = typeCmdStoredProc);
int GetRecordsAffected()
{return m_nRecordsA};
_CommandPtr GetCommand()
{return m_pC};
protected:
void dump_com_error(_com_error &e);
protected:
_CommandPtr m_pC
int m_nCommandT
int m_nRecordsA
CString m_strCommandT
CString m_strLastE
DWORD m_dwLastE
/////////////////////////////////////////////////////////////////////
// CADOException Class
class CADOException
CADOException() :
m_lErrorCode(0),
m_strError(_T(""))
CADOException(long lErrorCode) :
m_lErrorCode(lErrorCode),
m_strError(_T(""))
CADOException(long lErrorCode, const CString& strError)
m_lErrorCode(lErrorCode),
m_strError(strError)
CADOException(const CString& strError) :
m_lErrorCode(0),
m_strError(strError)
CADOException(long lErrorCode, const char* szError) :
m_lErrorCode(lErrorCode),
m_strError(szError)
CADOException(const char* szError) :
m_lErrorCode(0),
m_strError(szError)
virtual ~CADOException()
CString GetErrorMessage() const
{return m_strE};
void SetErrorMessage(LPCSTR lpstrError = _T(""))
{m_strError = lpstrE};
long GetError()
{return m_lErrorC};
void SetError(long lErrorCode = 0)
{m_lErrorCode = lErrorC};
protected:
CString m_strE
long m_lErrorC
#endif //AFX_ADO2_H_INCLUDED_
************************************Ado2.h*********************************************
************************************Ado2.cpp*********************************************
// MODULE: Ado2.cpp
// AUTHOR: Carlos Antollini
// Copyright (c) . All Rights Reserved.
// Date: August 01, 2005
// Version 2.20
// This code may be used in compiled form in any way you
desire. This
// file may be redistributed unmodified by any means PROVIDING
// not sold for profit without the authors written consent,
// providing that this notice and the authors name and all
copyright&
// notices remains intact.&
// An email letting me know how you are using it would be nice
// This file is provided "as is" with no expressed or implied
// The author accepts no liability for any damage/loss of
business that
// this product may cause.
//////////////////////////////////////////////////////////////////////
#include "ado2.h"
#define ChunkSize 100
///////////////////////////////////////////////////////
// CJetEngine Class
BOOL CJetEngine::CompactDatabase(CString strDatabaseSource,
CString strDatabaseDestination)
::CoInitialize(NULL);
IJetEnginePtr jet(__uuidof(JetEngine));
HRESULT hr =
jet-&CompactDatabase(_bstr_t(strDatabaseSource.GetBuffer(0)),
_bstr_t(strDatabaseDestination.GetBuffer(0)));
jet.Release();
::CoUninitialize();
return hr == S_OK;
catch(_com_error)&
::CoUninitialize();
return FALSE;
BOOL CJetEngine::RefreshCache(ADODB::_Connection *pconn)
//Added by doodle@email.it
::CoInitialize(NULL);
IJetEnginePtr
jet(__uuidof(JetEngine));&
HRESULT hr = jet-&RefreshCache(pconn);
::CoUninitialize();
return hr == S_OK;
catch(_com_error)&
::CoUninitialize();
return FALSE;
return FALSE;
///////////////////////////////////////////////////////
// CADODatabase Class
DWORD CADODatabase::GetRecordCount(_RecordsetPtr m_pRs)
DWORD numRows = 0;
numRows = m_pRs-&GetRecordCount();
if(numRows == -1)
if(m_pRs-&EndOfFile != VARIANT_TRUE)
m_pRs-&MoveFirst();
while(m_pRs-&EndOfFile != VARIANT_TRUE)
numRows++;
m_pRs-&MoveNext();
if(numRows & 0)
m_pRs-&MoveFirst();
return numR
BOOL CADODatabase::Open(LPCTSTR lpstrConnection, LPCTSTR
lpstrUserID, LPCTSTR lpstrPassword)
HRESULT hr = S_OK;
if(IsOpen())
if(strcmp(lpstrConnection, _T("")) != 0)
m_strConnection = lpstrC
ASSERT(!m_strConnection.IsEmpty());
if(m_nConnectionTimeout != 0)
m_pConnection-&PutConnectionTimeout(m_nConnectionTimeout);
hr = m_pConnection-&Open(_bstr_t(m_strConnection),
_bstr_t(lpstrUserID), _bstr_t(lpstrPassword), NULL);
return hr == S_OK;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
void CADODatabase::dump_com_error(_com_error &e)
CString ErrorS
_bstr_t bstrSource(e.Source());
_bstr_t bstrDescription(e.Description());
ErrorStr.Format( "CADODataBase Error\n\tCode = lx\n\tCode
meaning = %s\n\tSource = %s\n\tDescription = %s\n",
e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource,
(LPCSTR)bstrDescription);
m_strErrorDescription = (LPCSTR)bstrD
m_strLastError = _T("Connection String = " +
GetConnectionString() + '\n' + ErrorStr);
m_dwLastError = e.Error();&
#ifdef _DEBUG
AfxMessageBox(ErrorStr, MB_OK | MB_ICONERROR );
throw CADOException(e.Error(), e.Description());
BOOL CADODatabase::IsOpen()
if(m_pConnection )
return m_pConnection-&GetState() != adStateC
return FALSE;
void CADODatabase::Close()
if(IsOpen())
m_pConnection-&Close();
///////////////////////////////////////////////////////
// CADORecordset Class
CADORecordset::CADORecordset()
m_pRecordset = NULL;
m_pCmd = NULL;
m_strQuery = _T("");
m_strLastError = _T("");
m_dwLastError = 0;
m_pRecBinding = NULL;
m_pRecordset.CreateInstance(__uuidof(Recordset));
m_pCmd.CreateInstance(__uuidof(Command));
m_nEditStatus = CADORecordset::dbEditN
m_nSearchDirection = CADORecordset::searchF
CADORecordset::CADORecordset(CADODatabase* pAdoDatabase)
m_pRecordset = NULL;
m_pCmd = NULL;
m_strQuery = _T("");
m_strLastError = _T("");
m_dwLastError = 0;
m_pRecBinding = NULL;
m_pRecordset.CreateInstance(__uuidof(Recordset));
m_pCmd.CreateInstance(__uuidof(Command));
m_nEditStatus = CADORecordset::dbEditN
m_nSearchDirection = CADORecordset::searchF
m_pConnection = pAdoDatabase-&GetActiveConnection();
BOOL CADORecordset::Open(_ConnectionPtr mpdb, LPCTSTR
lpstrExec, int nOption)
if(strcmp(lpstrExec, _T("")) != 0)
m_strQuery = lpstrE
ASSERT(!m_strQuery.IsEmpty());
if(m_pConnection == NULL)
m_pConnection =
m_strQuery.TrimLeft();
BOOL bIsSelect = m_strQuery.Mid(0, strlen("Select
")).CompareNoCase("select ") == 0 && nOption ==
m_pRecordset-&CursorType = adOpenS
m_pRecordset-&CursorLocation = adUseC
if(bIsSelect || nOption == openQuery || nOption ==
openUnknown)
m_pRecordset-&Open((LPCSTR)m_strQuery,
_variant_t((IDispatch*)mpdb, TRUE),&
adOpenStatic, adLockOptimistic, adCmdUnknown);
else if(nOption == openTable)
m_pRecordset-&Open((LPCSTR)m_strQuery,
_variant_t((IDispatch*)mpdb, TRUE),&
adOpenKeyset, adLockOptimistic, adCmdTable);
else if(nOption == openStoredProc)
m_pCmd-&ActiveConnection =
m_pCmd-&CommandText = _bstr_t(m_strQuery);
m_pCmd-&CommandType = adCmdStoredP
m_pConnection-&CursorLocation = adUseC
m_pRecordset = m_pCmd-&Execute(NULL, NULL,
adCmdText);
TRACE( "Unknown parameter. %d", nOption);
return FALSE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
return m_pRecordset != NULL &&
m_pRecordset-&GetState()!= adStateC
BOOL CADORecordset::Open(LPCTSTR lpstrExec, int nOption)
ASSERT(m_pConnection != NULL);
ASSERT(m_pConnection-&GetState() != adStateClosed);
return Open(m_pConnection, lpstrExec, nOption);
BOOL CADORecordset::OpenSchema(int nSchema, LPCTSTR SchemaID
_variant_t vtSchemaID = vtM
if(strlen(SchemaID) != 0)
vtSchemaID = SchemaID;
nSchema = adSchemaProviderSpecific;
m_pRecordset = m_pConnection-&OpenSchema((enum
SchemaEnum)nSchema, vtMissing, vtSchemaID);
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::Requery()
if(IsOpen())
m_pRecordset-&Requery(adExecuteRecord);
catch(_com_error &e)
dump_com_error(e);
return FALSE;
return TRUE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
double& dbValue)
double val = (double)NULL;
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
switch(vtFld.vt)
case VT_R4:
val = vtFld.fltV
case VT_R8:
val = vtFld.dblV
case VT_DECIMAL:
//Corrected by Jos?Carlos Mart韓ez Gal醤
val = vtFld.decVal.Lo32;
val *= (vtFld.decVal.sign == 128)? -1 : 1;
val /= pow(10, vtFld.decVal.scale);&
case VT_UI1:
val = vtFld.iV
case VT_I2:
case VT_I4:
val = vtFld.lV
case VT_INT:
val = vtFld.intV
case VT_CY: & //Added by John Andy
Johnson!!!!
vtFld.ChangeType(VT_R8);
val = vtFld.dblV
case VT_NULL:
case VT_EMPTY:
val = vtFld.dblV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex, double&
double val = (double)NULL;
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
switch(vtFld.vt)
case VT_R4:
val = vtFld.fltV
case VT_R8:
val = vtFld.dblV
case VT_DECIMAL:
//Corrected by Jos?Carlos Mart韓ez Gal醤
val = vtFld.decVal.Lo32;
val *= (vtFld.decVal.sign == 128)? -1 : 1;
val /= pow(10, vtFld.decVal.scale);&
case VT_UI1:
val = vtFld.iV
case VT_I2:
case VT_I4:
val = vtFld.lV
case VT_INT:
val = vtFld.intV
case VT_CY: & //Added by John Andy
Johnson!!!!
vtFld.ChangeType(VT_R8);
val = vtFld.dblV
case VT_NULL:
case VT_EMPTY:
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
long& lValue)
long val = (long)NULL;
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
val = vtFld.lV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex, long&
long val = (long)NULL;
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
val = vtFld.lV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
unsigned long& ulValue)
long val = (long)NULL;
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
val = vtFld.ulV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex, unsigned
long& ulValue)
long val = (long)NULL;
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
val = vtFld.ulV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
int& nValue)
int val = NULL;
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
switch(vtFld.vt)
case VT_BOOL:
val = vtFld.boolV
case VT_I2:
case VT_UI1:
val = vtFld.iV
case VT_INT:
val = vtFld.intV
case VT_NULL:
case VT_EMPTY:
val = vtFld.iV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex, int&
int val = (int)NULL;
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
switch(vtFld.vt)
case VT_BOOL:
val = vtFld.boolV
case VT_I2:
case VT_UI1:
val = vtFld.iV
case VT_INT:
val = vtFld.intV
case VT_NULL:
case VT_EMPTY:
val = vtFld.iV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
CString& strValue, CString strDateFormat)
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
switch(vtFld.vt)&
case VT_R4:
str = DblToStr(vtFld.fltVal);
case VT_R8:
str = DblToStr(vtFld.dblVal);
case VT_BSTR:
str = vtFld.bstrV
case VT_I2:
case VT_UI1:
str = IntToStr(vtFld.iVal);
case VT_INT:
str = IntToStr(vtFld.intVal);
case VT_I4:
str = LongToStr(vtFld.lVal);
case VT_UI4:
str = ULongToStr(vtFld.ulVal);
case VT_DECIMAL:
//Corrected by Jos?Carlos Mart韓ez Gal醤
double val = vtFld.decVal.Lo32;
val *= (vtFld.decVal.sign == 128)? -1 : 1;
val /= pow(10, vtFld.decVal.scale);&
str = DblToStr(val);
case VT_DATE:
COleDateTime dt(vtFld);
if(strDateFormat.IsEmpty())
strDateFormat = _T("%Y-%m-%d %H:%M:%S");
str = dt.Format(strDateFormat);
case VT_CY: //Added by John Andy Johnson!!!
vtFld.ChangeType(VT_R8);
str.Format(_T("%f"), vtFld.dblVal);
_TCHAR pszFormattedNumber[64];
// LOCALE_USER_DEFAULT
if(GetCurrencyFormat(
LOCALE_USER_DEFAULT, // locale for which string is to be
formatted&
0, // bit flag that controls the function's operation
str, // pointer to input number string
NULL, // pointer to a formatting information structure
// NULL = machine default locale settings
pszFormattedNumber, // pointer to output buffer
63)) // size of output buffer
str = pszFormattedN
case VT_EMPTY:
case VT_NULL:
str.Empty();
case VT_BOOL:
str = vtFld.boolVal == VARIANT_TRUE? 'T':'F';
str.Empty();
return FALSE;
strValue =
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex, CString&
strValue, CString strDateFormat)
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
switch(vtFld.vt)&
case VT_R4:
str = DblToStr(vtFld.fltVal);
case VT_R8:
str = DblToStr(vtFld.dblVal);
case VT_BSTR:
str = vtFld.bstrV
case VT_I2:
case VT_UI1:
str = IntToStr(vtFld.iVal);
case VT_INT:
str = IntToStr(vtFld.intVal);
case VT_I4:
str = LongToStr(vtFld.lVal);
case VT_UI4:
str = ULongToStr(vtFld.ulVal);
case VT_DECIMAL:
//Corrected by Jos?Carlos Mart韓ez Gal醤
double val = vtFld.decVal.Lo32;
val *= (vtFld.decVal.sign == 128)? -1 : 1;
val /= pow(10, vtFld.decVal.scale);&
str = DblToStr(val);
case VT_DATE:
COleDateTime dt(vtFld);
if(strDateFormat.IsEmpty())
strDateFormat = _T("%Y-%m-%d %H:%M:%S");
str = dt.Format(strDateFormat);
case VT_CY: //Added by John Andy Johnson!!!
vtFld.ChangeType(VT_R8);
str.Format(_T("%f"), vtFld.dblVal);
_TCHAR pszFormattedNumber[64];
// LOCALE_USER_DEFAULT
if(GetCurrencyFormat(
LOCALE_USER_DEFAULT, // locale for which string is to be
formatted&
0, // bit flag that controls the function's operation
str, // pointer to input number string
NULL, // pointer to a formatting information structure
// NULL = machine default locale settings
pszFormattedNumber, // pointer to output buffer
63)) // size of output buffer
str = pszFormattedN
case VT_BOOL:
str = vtFld.boolVal == VARIANT_TRUE? 'T':'F';
case VT_EMPTY:
case VT_NULL:
str.Empty();
str.Empty();
return FALSE;
strValue =
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
COleDateTime& time)
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
switch(vtFld.vt)&
case VT_DATE:
COleDateTime dt(vtFld);
case VT_EMPTY:
case VT_NULL:
time.SetStatus(COleDateTime::null);
return FALSE;
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex,
COleDateTime& time)
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
switch(vtFld.vt)&
case VT_DATE:
COleDateTime dt(vtFld);
case VT_EMPTY:
case VT_NULL:
time.SetStatus(COleDateTime::null);
return FALSE;
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
bool& bValue)
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
switch(vtFld.vt)&
case VT_BOOL:
bValue = vtFld.boolVal == VARIANT_TRUE? true:
case VT_EMPTY:
case VT_NULL:
return FALSE;
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex, bool&
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
switch(vtFld.vt)&
case VT_BOOL:
bValue = vtFld.boolVal == VARIANT_TRUE? true:
case VT_EMPTY:
case VT_NULL:
return FALSE;
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
COleCurrency& cyValue)
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
switch(vtFld.vt)&
case VT_CY:
cyValue = (CURRENCY)vtFld.cyV
case VT_EMPTY:
case VT_NULL:
cyValue = COleCurrency();
cyValue.m_status = COleCurrency::
return FALSE;
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex,
COleCurrency& cyValue)
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
switch(vtFld.vt)&
case VT_CY:
cyValue = (CURRENCY)vtFld.cyV
case VT_EMPTY:
case VT_NULL:
cyValue = COleCurrency();
cyValue.m_status = COleCurrency::
return FALSE;
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName,
_variant_t& vtValue)
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::GetFieldValue(int nIndex, _variant_t&
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::IsFieldNull(LPCTSTR lpFieldName)
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
return vtFld.vt == VT_NULL;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::IsFieldNull(int nIndex)
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
return vtFld.vt == VT_NULL;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::IsFieldEmpty(LPCTSTR lpFieldName)
_variant_t vtF
m_pRecordset-&Fields-&GetItem(lpFieldName)-&V
return vtFld.vt == VT_EMPTY || vtFld.vt == VT_NULL;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::IsFieldEmpty(int nIndex)
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
m_pRecordset-&Fields-&GetItem(vtIndex)-&V
return vtFld.vt == VT_EMPTY || vtFld.vt == VT_NULL;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::SetFieldEmpty(LPCTSTR lpFieldName)
_variant_t vtF
vtFld.vt = VT_EMPTY;
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldEmpty(int nIndex)
_variant_t vtF
vtFld.vt = VT_EMPTY;
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
DWORD CADORecordset::GetRecordCount()
DWORD nRows = 0;
nRows = m_pRecordset-&GetRecordCount();
if(nRows == -1)
nRows = 0;
if(m_pRecordset-&EndOfFile != VARIANT_TRUE)
m_pRecordset-&MoveFirst();
while(m_pRecordset-&EndOfFile != VARIANT_TRUE)
m_pRecordset-&MoveNext();
if(nRows & 0)
m_pRecordset-&MoveFirst();
BOOL CADORecordset::IsOpen()
if(m_pRecordset != NULL && IsConnectionOpen())
return m_pRecordset-&GetState() != adStateC
return FALSE;
void CADORecordset::Close()
if(IsOpen())
if (m_nEditStatus != dbEditNone)
&CancelUpdate();
m_pRecordset-&PutSort(_T(""));
m_pRecordset-&Close();
BOOL CADODatabase::Execute(LPCTSTR lpstrExec)
ASSERT(m_pConnection != NULL);
ASSERT(strcmp(lpstrExec, _T("")) != 0);
_variant_t vR
m_nRecordsAffected = 0;
m_pConnection-&CursorLocation = adUseC
m_pConnection-&Execute(_bstr_t(lpstrExec), &vRecords,
adExecuteNoRecords);
m_nRecordsAffected = vRecords.iV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::RecordBinding(CADORecordBinding
&pAdoRecordBinding)
m_pRecBinding = NULL;
//Open the binding interface.
if(FAILED(hr =
m_pRecordset-&QueryInterface(__uuidof(IADORecordBinding),
(LPVOID*)&m_pRecBinding )))
_com_issue_error(hr);
return FALSE;
//Bind the recordset to class
if(FAILED(hr =
m_pRecBinding-&BindToRecordset(&pAdoRecordBinding)))
_com_issue_error(hr);
return FALSE;
return TRUE;
BOOL CADORecordset::GetFieldInfo(LPCTSTR lpFieldName,
CADOFieldInfo* fldInfo)
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(lpFieldName);
return GetFieldInfo(pField, fldInfo);
BOOL CADORecordset::GetFieldInfo(int nIndex, CADOFieldInfo*
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(vtIndex);
return GetFieldInfo(pField, fldInfo);
BOOL CADORecordset::GetFieldInfo(FieldPtr pField,
CADOFieldInfo* fldInfo)
memset(fldInfo, 0, sizeof(CADOFieldInfo));
strcpy(fldInfo-&m_strName,
(LPCTSTR)pField-&GetName());
fldInfo-&m_lDefinedSize =
pField-&GetDefinedSize();
fldInfo-&m_nType = pField-&GetType();
fldInfo-&m_lAttributes = pField-&GetAttributes();
if(!IsEof())
fldInfo-&m_lSize = pField-&GetActualSize();
return TRUE;
BOOL CADORecordset::GetChunk(LPCTSTR lpFieldName, CString&
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(lpFieldName);
return GetChunk(pField, strValue);
BOOL CADORecordset::GetChunk(int nIndex, CString&
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(vtIndex);
return GetChunk(pField, strValue);
BOOL CADORecordset::GetChunk(FieldPtr pField, CString&
long lngSize, lngOffSet = 0;
_variant_t varC
lngSize = pField-&ActualS
str.Empty();
while(lngOffSet & lngSize)
varChunk = pField-&GetChunk(ChunkSize);
str += varChunk.bstrV
lngOffSet += ChunkS
catch(_com_error &e)
dump_com_error(e);
return FALSE;
lngOffSet = 0;
strValue =
return TRUE;
BOOL CADORecordset::GetChunk(LPCTSTR lpFieldName, LPVOID
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(lpFieldName);
return GetChunk(pField, lpData);
BOOL CADORecordset::GetChunk(int nIndex, LPVOID lpData)
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(vtIndex);
return GetChunk(pField, lpData);
BOOL CADORecordset::GetChunk(FieldPtr pField, LPVOID
long lngSize, lngOffSet = 0;
_variant_t varC &
long lBytesCopied = 0;
lngSize = pField-&ActualS
while(lngOffSet & lngSize)
varChunk = pField-&GetChunk(ChunkSize);
//Copy the data only upto the Actual Size of Field.
& & & for(long
lIndex = 0; lIndex &= (ChunkSize - 1); lIndex++)
SafeArrayGetElement(varChunk.parray, &lIndex,
& & if(SUCCEEDED(hr))
& //Take BYTE by BYTE and advance Memory
& //hr = SafeArrayPutElement((SAFEARRAY
FAR*)lpData, &lBytesCopied
,&chData);&
((UCHAR*)lpData)[lBytesCopied] = chD
& lBytesCopied++;
lngOffSet += ChunkS
catch(_com_error &e)
dump_com_error(e);
return FALSE;
lngOffSet = 0;
return TRUE;
BOOL CADORecordset::AppendChunk(LPCTSTR lpFieldName, LPVOID
lpData, UINT nBytes)
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(lpFieldName);
return AppendChunk(pField, lpData, nBytes);
BOOL CADORecordset::AppendChunk(int nIndex, LPVOID lpData,
UINT nBytes)
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
FieldPtr pField =
m_pRecordset-&Fields-&GetItem(vtIndex);
return AppendChunk(pField, lpData, nBytes);
BOOL CADORecordset::AppendChunk(FieldPtr pField, LPVOID
lpData, UINT nBytes)
_variant_t varC
long lngOffset = 0;
SAFEARRAY FAR *psa = NULL;
SAFEARRAYBOUND rgsabound[1];
//Create a safe array to store the array of
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = nB
psa = SafeArrayCreate(VT_UI1,1,rgsabound);
while(lngOffset & (long)nBytes)
chData = ((UCHAR*)lpData)[lngOffset];
hr = SafeArrayPutElement(psa, &lngOffset,
if(FAILED(hr))
return FALSE;
lngOffset++;
lngOffset = 0;
//Assign the Safe array &to a
varChunk.vt = VT_ARRAY|VT_UI1;
varChunk.parray =
hr = pField-&AppendChunk(varChunk);
if(SUCCEEDED(hr)) return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
return FALSE;
CString CADORecordset::GetString(LPCTSTR lpCols, LPCTSTR
lpRows, LPCTSTR lpNull, long numRows)
_bstr_t varO
_bstr_t varNull("");
_bstr_t varCols("\t");
_bstr_t varRows("\r");
if(strlen(lpCols) != 0)
varCols = _bstr_t(lpCols);
if(strlen(lpRows) != 0)
varRows = _bstr_t(lpRows);
if(numRows == 0)
numRows =(long)GetRecordCount();
varOutput = m_pRecordset-&GetString(adClipString, numRows,
varCols, varRows, varNull);
return (LPCTSTR)varO
CString IntToStr(int nVal)
CString strR
char buff[10];
itoa(nVal, buff, 10);
return strR
CString LongToStr(long lVal)
CString strR
char buff[20];
ltoa(lVal, buff, 10);
return strR
CString ULongToStr(unsigned long ulVal)
CString strR
char buff[20];
ultoa(ulVal, buff, 10);
return strR
CString DblToStr(double dblVal, int ndigits)
CString strR
char buff[50];
& &_gcvt(dblVal, ndigits,
return strR
CString DblToStr(float fltVal)
CString strR
char buff[50];
& &_gcvt(fltVal, 10,
return strR
void CADORecordset::Edit()
m_nEditStatus = dbE
BOOL CADORecordset::AddNew()
m_nEditStatus = dbEditN
if(m_pRecordset-&AddNew() != S_OK)
return FALSE;
m_nEditStatus = dbEditN
return TRUE;
BOOL CADORecordset::AddNew(CADORecordBinding
&pAdoRecordBinding)
if(m_pRecBinding-&AddNew(&pAdoRecordBinding) !=
return FALSE;
m_pRecBinding-&Update(&pAdoRecordBinding);
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::Update()
BOOL bret = TRUE;
if(m_nEditStatus != dbEditNone)
if(m_pRecordset-&Update() != S_OK)
bret = FALSE;
catch(_com_error &e)
dump_com_error(e);
bret = FALSE;
m_pRecordset-&CancelUpdate();
m_nEditStatus = dbEditN
void CADORecordset::CancelUpdate()
m_pRecordset-&CancelUpdate();
m_nEditStatus = dbEditN
BOOL CADORecordset::SetFieldValue(int nIndex, CString
_variant_t vtF
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
if(!strValue.IsEmpty())
vtFld.vt = VT_BSTR;
vtFld.vt = VT_NULL;
//Corrected by Giles Forster 10/03/2001
vtFld.bstrVal = strValue.AllocSysString();
BOOL bret = PutFieldValue(vtIndex, vtFld);
//Corrected by Flemming27 at CodeProject.com
SysFreeString(vtFld.bstrVal);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, CString
_variant_t vtF
if(!strValue.IsEmpty())
vtFld.vt = VT_BSTR;
vtFld.vt = VT_NULL;
//Corrected by Giles Forster 10/03/2001
vtFld.bstrVal = strValue.AllocSysString();
BOOL bret = &PutFieldValue(lpFieldName,
//Corrected by Flemming27 at CodeProject.com
SysFreeString(vtFld.bstrVal);
BOOL CADORecordset::SetFieldValue(int nIndex, int
_variant_t vtF
vtFld.vt = VT_I2;
vtFld.iVal = nV
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, int
_variant_t vtF
vtFld.vt = VT_I2;
vtFld.iVal = nV
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldValue(int nIndex, long
_variant_t vtF
vtFld.vt = VT_I4;
vtFld.lVal = lV
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, long
_variant_t vtF
vtFld.vt = VT_I4;
vtFld.lVal = lV
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldValue(int nIndex, unsigned long
_variant_t vtF
vtFld.vt = VT_UI4;
vtFld.ulVal = ulV
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName,
unsigned long ulValue)
_variant_t vtF
vtFld.vt = VT_UI4;
vtFld.ulVal = ulV
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldValue(int nIndex, double
_variant_t vtF
vtFld.vt = VT_R8;
vtFld.dblVal = dblV
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, double
_variant_t vtF
vtFld.vt = VT_R8;
vtFld.dblVal = dblV
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldValue(int nIndex, COleDateTime
_variant_t vtF
vtFld.vt = VT_DATE;
vtFld.date =
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName,
COleDateTime time)
_variant_t vtF
vtFld.vt = VT_DATE;
vtFld.date =
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldValue(int nIndex, bool
_variant_t vtF
vtFld.vt = VT_BOOL;
vtFld.boolVal = bV
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, bool
_variant_t vtF
vtFld.vt = VT_BOOL;
vtFld.boolVal = bV
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldValue(int nIndex, COleCurrency
if(cyValue.m_status == COleCurrency::invalid)
return FALSE;
_variant_t vtF
vtFld.vt = VT_CY;
vtFld.cyVal = cyValue.m_
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtFld);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName,
COleCurrency cyValue)
if(cyValue.m_status == COleCurrency::invalid)
return FALSE;
_variant_t vtF
vtFld.vt = VT_CY;
vtFld.cyVal = cyValue.m_
return PutFieldValue(lpFieldName, vtFld);
BOOL CADORecordset::SetFieldValue(int nIndex, _variant_t
_variant_t vtI
vtIndex.vt = VT_I2;
vtIndex.iVal = nI
return PutFieldValue(vtIndex, vtValue);
BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName,
_variant_t vtValue)
return PutFieldValue(lpFieldName, vtValue);
BOOL CADORecordset::SetBookmark()
if(m_varBookmark.vt != VT_EMPTY)
m_pRecordset-&Bookmark = m_varB
return TRUE;
return FALSE;
BOOL CADORecordset::Delete()
if(m_pRecordset-&Delete(adAffectCurrent) != S_OK)
return FALSE;
if(m_pRecordset-&Update() != S_OK)
return FALSE;
m_nEditStatus = dbEditN
return TRUE;
BOOL CADORecordset::Find(LPCTSTR lpFind, int
nSearchDirection)
m_strFind = lpF
m_nSearchDirection = nSearchD
ASSERT(!m_strFind.IsEmpty());
if(m_nSearchDirection == searchForward)
m_pRecordset-&Find(_bstr_t(m_strFind), 0, adSearchForward,
if(!IsEof())
m_varBookFind = m_pRecordset-&B
return TRUE;
else if(m_nSearchDirection == searchBackward)
m_pRecordset-&Find(_bstr_t(m_strFind), 0, adSearchBackward,
if(!IsBof())
m_varBookFind = m_pRecordset-&B
return TRUE;
TRACE("Unknown parameter. %d", nSearchDirection);
m_nSearchDirection = searchF
return FALSE;
BOOL CADORecordset::FindFirst(LPCTSTR lpFind)
m_pRecordset-&MoveFirst();
return Find(lpFind);
BOOL CADORecordset::FindNext()
if(m_nSearchDirection == searchForward)
m_pRecordset-&Find(_bstr_t(m_strFind), 1, adSearchForward,
m_varBookFind);
if(!IsEof())
m_varBookFind = m_pRecordset-&B
return TRUE;
m_pRecordset-&Find(_bstr_t(m_strFind), 1, adSearchBackward,
m_varBookFind);
if(!IsBof())
m_varBookFind = m_pRecordset-&B
return TRUE;
return FALSE;
BOOL CADORecordset::PutFieldValue(LPCTSTR lpFieldName,
_variant_t vtFld)
if(m_nEditStatus == dbEditNone)
return FALSE;
m_pRecordset-&Fields-&GetItem(lpFieldName)-&Value =
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::PutFieldValue(_variant_t vtIndex,
_variant_t vtFld)
if(m_nEditStatus == dbEditNone)
return FALSE;
m_pRecordset-&Fields-&GetItem(vtIndex)-&Value =
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::Clone(CADORecordset &pRs)
pRs.m_pRecordset =
m_pRecordset-&Clone(adLockUnspecified);
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::SetFilter(LPCTSTR strFilter)
ASSERT(IsOpen());
m_pRecordset-&PutFilter(strFilter);
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::SetSort(LPCTSTR strCriteria)
ASSERT(IsOpen());
m_pRecordset-&PutSort(strCriteria);
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::SaveAsXML(LPCTSTR lpstrXMLFile)
ASSERT(IsOpen());
hr = m_pRecordset-&Save(lpstrXMLFile, adPersistXML);
return hr == S_OK;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
return TRUE;
BOOL CADORecordset::OpenXML(LPCTSTR lpstrXMLFile)
HRESULT hr = S_OK;
if(IsOpen())
hr = m_pRecordset-&Open(lpstrXMLFile,
"Provider=MSP", adOpenForwardOnly, adLockOptimistic,
adCmdFile);
return hr == S_OK;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADORecordset::Execute(CADOCommand* pAdoCommand)
if(IsOpen())
ASSERT(!pAdoCommand-&GetText().IsEmpty());
m_pConnection-&CursorLocation = adUseC
m_pRecordset = pAdoCommand-&GetCommand()-&Execute(NULL,
NULL, pAdoCommand-&GetType());
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
void CADORecordset::dump_com_error(_com_error &e)
CString ErrorS
_bstr_t bstrSource(e.Source());
_bstr_t bstrDescription(e.Description());
ErrorStr.Format( "CADORecordset Error\n\tCode = lx\n\tCode
meaning = %s\n\tSource = %s\n\tDescription = %s\n",
e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource,
(LPCSTR)bstrDescription );
m_strLastError = _T("Query = " + GetQuery() + '\n' +
ErrorStr);
m_dwLastError = e.Error();
#ifdef _DEBUG
AfxMessageBox( ErrorStr, MB_OK | MB_ICONERROR );
throw CADOException(e.Error(), e.Description());
///////////////////////////////////////////////////////
// CADOCommad Class
CADOCommand::CADOCommand(CADODatabase* pAdoDatabase, CString
strCommandText, int nCommandType)
m_pCommand = NULL;
m_pCommand.CreateInstance(__uuidof(Command));
m_strCommandText = strCommandT
m_pCommand-&CommandText =
m_strCommandText.AllocSysString();
m_nCommandType = nCommandT
m_pCommand-&CommandType =
(CommandTypeEnum)m_nCommandT
m_pCommand-&ActiveConnection =
pAdoDatabase-&GetActiveConnection();
m_nRecordsAffected = 0;
BOOL CADOCommand::AddParameter(CADOParameter*
pAdoParameter)
ASSERT(pAdoParameter-&GetParameter() != NULL);
m_pCommand-&Parameters-&Append(pAdoParameter-&GetParameter());
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
BOOL CADOCommand::AddParameter(CString strName, int nType, int
nDirection, long lSize, int nValue)
_variant_t vtV
vtValue.vt = VT_I2;
vtValue.iVal = nV
return AddParameter(strName, nType, nDirection, lSize,
BOOL CADOCommand::AddParameter(CString strName, int nType, int
nDirection, long lSize, long lValue)
_variant_t vtV
vtValue.vt = VT_I4;
vtValue.lVal = lV
return AddParameter(strName, nType, nDirection, lSize,
BOOL CADOCommand::AddParameter(CString strName, int nType, int
nDirection, long lSize, double dblValue, int nPrecision, int
_variant_t vtV
vtValue.vt = VT_R8;
vtValue.dblVal = dblV
return AddParameter(strName, nType, nDirection, lSize,
vtValue, nPrecision, nScale);
BOOL CADOCommand::AddParameter(CString strName, int nType, int
nDirection, long lSize, CString strValue)
_variant_t vtV
vtValue.vt = VT_BSTR;
vtValue.bstrVal = strValue.AllocSysString();
return AddParameter(strName, nType, nDirection, lSize,
BOOL CADOCommand::AddParameter(CString strName, int nType, int
nDirection, long lSize, COleDateTime time)
_variant_t vtV
vtValue.vt = VT_DATE;
vtValue.date =
return AddParameter(strName, nType, nDirection, lSize,
BOOL CADOCommand::AddParameter(CString strName, int nType, int
nDirection, long lSize, _variant_t vtValue, int nPrecision, int
_ParameterPtr pParam =
m_pCommand-&CreateParameter(strName.AllocSysString(),
(DataTypeEnum)nType, (ParameterDirectionEnum)nDirection, lSize,
pParam-&PutPrecision(nPrecision);
pParam-&PutNumericScale(nScale);
m_pCommand-&Parameters-&Append(pParam);
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
void CADOCommand::SetText(CString strCommandText)
ASSERT(!strCommandText.IsEmpty());
m_strCommandText = strCommandT
m_pCommand-&CommandText =
m_strCommandText.AllocSysString();
void CADOCommand::SetType(int nCommandType)
m_nCommandType = nCommandT
m_pCommand-&CommandType =
(CommandTypeEnum)m_nCommandT
BOOL CADOCommand::Execute(int nCommandType )
_variant_t vR
m_nRecordsAffected = 0;
m_nCommandType = nCommandT
m_pCommand-&Execute(&vRecords, NULL,
nCommandType);
m_nRecordsAffected = vRecords.iV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
void CADOCommand::dump_com_error(_com_error &e)
CString ErrorS
_bstr_t bstrSource(e.Source());
_bstr_t bstrDescription(e.Description());
ErrorStr.Format( "CADOCommand Error\n\tCode = lx\n\tCode
meaning = %s\n\tSource = %s\n\tDescription = %s\n",
e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource,
(LPCSTR)bstrDescription );
m_strLastError = ErrorS
m_dwLastError = e.Error();
#ifdef _DEBUG
AfxMessageBox(ErrorStr, MB_OK | MB_ICONERROR);
throw CADOException(e.Error(), e.Description());
///////////////////////////////////////////////////////
// CADOParameter Class
CADOParameter::CADOParameter(int nType, long lSize, int
nDirection, CString strName)
m_pParameter = NULL;
m_pParameter.CreateInstance(__uuidof(Parameter));
m_strName = _T("");
m_pParameter-&Direction =
(ParameterDirectionEnum)nD
m_strName = strN
m_pParameter-&Name = m_strName.AllocSysString();
m_pParameter-&Type = (DataTypeEnum)nT
m_pParameter-&Size = lS
m_nType = nT
BOOL CADOParameter::SetValue(int nValue)
_variant_t vtV
ASSERT(m_pParameter != NULL);
vtVal.vt = VT_I2;
vtVal.iVal = nV
if(m_pParameter-&Size == 0)
m_pParameter-&Size = sizeof(int);
m_pParameter-&Value = vtV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::SetValue(long lValue)
_variant_t vtV
ASSERT(m_pParameter != NULL);
vtVal.vt = VT_I4;
vtVal.lVal = lV
if(m_pParameter-&Size == 0)
m_pParameter-&Size = sizeof(long);
m_pParameter-&Value = vtV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::SetValue(double dblValue)
_variant_t vtV
ASSERT(m_pParameter != NULL);
vtVal.vt = VT_R8;
vtVal.dblVal = dblV
if(m_pParameter-&Size == 0)
m_pParameter-&Size = sizeof(double);
m_pParameter-&Value = vtV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::SetValue(CString strValue)
_variant_t vtV
ASSERT(m_pParameter != NULL);
if(!strValue.IsEmpty())
vtVal.vt = VT_BSTR;
vtVal.vt = VT_NULL;
//Corrected by Giles Forster 10/03/2001
vtVal.bstrVal = strValue.AllocSysString();
//vtVal.SetString(strValue.GetBuffer(0));
if(m_pParameter-&Size == 0)
m_pParameter-&Size = sizeof(char) *
strValue.GetLength();
m_pParameter-&Value = vtV
::SysFreeString(vtVal.bstrVal);
return TRUE;
catch(_com_error &e)
dump_com_error(e);
::SysFreeString(vtVal.bstrVal);
return FALSE;
BOOL CADOParameter::SetValue(COleDateTime time)
_variant_t vtV
ASSERT(m_pParameter != NULL);
vtVal.vt = VT_DATE;
vtVal.date =
if(m_pParameter-&Size == 0)
m_pParameter-&Size = sizeof(DATE);
m_pParameter-&Value = vtV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::SetValue(_variant_t vtValue)
ASSERT(m_pParameter != NULL);
if(m_pParameter-&Size == 0)
m_pParameter-&Size = sizeof(VARIANT);
m_pParameter-&Value = vtV
return TRUE;
catch(_com_error &e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::GetValue(int& nValue)
_variant_t vtV
int nVal = 0;
vtVal = m_pParameter-&V
switch(vtVal.vt)
case VT_BOOL:
nVal = vtVal.boolV
case VT_I2:
case VT_UI1:
nVal = vtVal.iV
case VT_INT:
nVal = vtVal.intV
case VT_NULL:
case VT_EMPTY:
nVal = vtVal.iV
nValue = nV
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::GetValue(long& lValue)
_variant_t vtV
long lVal = 0;
vtVal = m_pParameter-&V
if(vtVal.vt != VT_NULL && vtVal.vt != VT_EMPTY)
lVal = vtVal.lV
lValue = lV
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::GetValue(double& dbValue)
_variant_t vtV
double dblV
vtVal = m_pParameter-&V
switch(vtVal.vt)
case VT_R4:
dblVal = vtVal.fltV
case VT_R8:
dblVal = vtVal.dblV
case VT_DECIMAL:
//Corrected by Jos?Carlos Mart韓ez Gal醤
dblVal = vtVal.decVal.Lo32;
dblVal *= (vtVal.decVal.sign == 128)? -1 : 1;
dblVal /= pow(10, vtVal.decVal.scale);&
case VT_UI1:
dblVal = vtVal.iV
case VT_I2:
case VT_I4:
dblVal = vtVal.lV
case VT_INT:
dblVal = vtVal.intV
case VT_NULL:
case VT_EMPTY:
dblVal = 0;
dblVal = 0;
dbValue = dblV
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::GetValue(CString& strValue, CString
strDateFormat)
_variant_t vtV
CString strV
vtVal = m_pParameter-&V
switch(vtVal.vt)&
case VT_R4:
strVal = DblToStr(vtVal.fltVal);
case VT_R8:
strVal = DblToStr(vtVal.dblVal);
case VT_BSTR:
strVal = vtVal.bstrV
case VT_I2:
case VT_UI1:
strVal = IntToStr(vtVal.iVal);
case VT_INT:
strVal = IntToStr(vtVal.intVal);
case VT_I4:
strVal = LongToStr(vtVal.lVal);
case VT_DECIMAL:
//Corrected by Jos?Carlos Mart韓ez Gal醤
double val = vtVal.decVal.Lo32;
val *= (vtVal.decVal.sign == 128)? -1 : 1;
val /= pow(10, vtVal.decVal.scale);&
strVal = DblToStr(val);
case VT_DATE:
COleDateTime dt(vtVal);
if(strDateFormat.IsEmpty())
strDateFormat = _T("%Y-%m-%d %H:%M:%S");
strVal = dt.Format(strDateFormat);
case VT_EMPTY:
case VT_NULL:
strVal.Empty();
strVal.Empty();
return FALSE;
strValue = strV
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::GetValue(COleDateTime& time)
_variant_t vtV
vtVal = m_pParameter-&V
switch(vtVal.vt)&
case VT_DATE:
COleDateTime dt(vtVal);
case VT_EMPTY:
case VT_NULL:
time.SetStatus(COleDateTime::null);
return FALSE;
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
BOOL CADOParameter::GetValue(_variant_t& vtValue)
vtValue = m_pParameter-&V
return TRUE;
catch(_com_error& e)
dump_com_error(e);
return FALSE;
void CADOParameter::dump_com_error(_com_error &e)
CString ErrorS
_bstr_t bstrSource(e.Source());
_bstr_t bstrDescription(e.Description());
ErrorStr.Format( "CADOParameter Error\n\tCode = lx\n\tCode
meaning = %s\n\tSource = %s\n\tDescription = %s\n",
e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource,
(LPCSTR)bstrDescription );
m_strLastError = ErrorS
m_dwLastError = e.Error();
#ifdef _DEBUG
AfxMessageBox(ErrorStr, MB_OK | MB_ICONERROR);
throw CADOException(e.Error(), e.Description());
************************************Ado2.cpp*********************************************
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。