ado操作类

原创 2005年02月26日 16:16:00

/////Ado.cpp
//
//  MODULE: Ado.cpp
//
// AUTHOR: Carlos Antollini
//
//  mailto: cantollini@hotmail.com
//
// Date: 11/19/2002
//
// Version 2.09
//

#include "stdafx.h"
#include "ado.h"

#define ChunkSize 100

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
///////////////////////////////////////////////////////
//
// 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 numRows;
}

BOOL CADODatabase::Open(LPCTSTR lpstrConnection, LPCTSTR lpstrUserID, LPCTSTR lpstrPassword)
{
 HRESULT hr = S_OK;

 if(IsOpen())
  Close();

 if(strcmp(lpstrConnection, _T("")) != 0)
  m_strConnection = lpstrConnection;

 ASSERT(!m_strConnection.IsEmpty());

 try
 {
  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 ErrorStr;
 
 _bstr_t bstrSource(e.Source());
 _bstr_t bstrDescription(e.Description());
 ErrorStr.Format( "CADODataBase Error/n/tCode = %08lx/n/tCode meaning = %s/n/tSource = %s/n/tDescription = %s/n",
  e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource, (LPCSTR)bstrDescription);
 m_strErrorDescription = (LPCSTR)bstrDescription ;
 m_strLastError = _T("Connection String = " + GetConnectionString() + '/n' + ErrorStr);
 m_dwLastError = e.Error();
 #ifdef _DEBUG
  AfxMessageBox(ErrorStr, MB_OK | MB_ICONERROR );
 #endif
}

BOOL CADODatabase::IsOpen()
{
 if(m_pConnection )
  return m_pConnection->GetState() != adStateClosed;
 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::dbEditNone;
 m_nSearchDirection = CADORecordset::searchForward;
}

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::dbEditNone;
 m_nSearchDirection = CADORecordset::searchForward;

 m_pConnection = pAdoDatabase->GetActiveConnection();
}

BOOL CADORecordset::Open(_ConnectionPtr mpdb, LPCTSTR lpstrExec, int nOption)

 Close();
 
 if(strcmp(lpstrExec, _T("")) != 0)
  m_strQuery = lpstrExec;

 ASSERT(!m_strQuery.IsEmpty());

 if(m_pConnection == NULL)
  m_pConnection = mpdb;

 m_strQuery.TrimLeft();
 BOOL bIsSelect = m_strQuery.Mid(0, strlen("Select ")).CompareNoCase("select ") == 0 && nOption == openUnknown;

 try
 {
  m_pRecordset->CursorType = adOpenStatic;
  m_pRecordset->CursorLocation = adUseClient;
  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 = mpdb;
   m_pCmd->CommandText = _bstr_t(m_strQuery);
   m_pCmd->CommandType = adCmdStoredProc;
   m_pConnection->CursorLocation = adUseClient;
   
   m_pRecordset = m_pCmd->Execute(NULL, NULL, adCmdText);
  }
  else
  {
   TRACE( "Unknown parameter. %d", nOption);
   return FALSE;
  }
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }

 return m_pRecordset != NULL;
}

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)
{
 try
 {
  _variant_t vtSchemaID = vtMissing;

  if(strlen(SchemaID) != 0)
   vtSchemaID = SchemaID;
   
  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())
 {
  try
  {
   // 如果提示adExecuteRecord无定义,请导入WIN2000下的msado15.dll
   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 vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  switch(vtFld.vt)
  {
  case VT_R4:
   val = vtFld.fltVal;
   break;
  case VT_R8:
   val = vtFld.dblVal;
   break;
  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);
   break;
  case VT_UI1:
   val = vtFld.iVal;
   break;
  case VT_I2:
  case VT_I4:
   val = vtFld.lVal;
   break;
  case VT_INT:
   val = vtFld.intVal;
   break;
  case VT_NULL:
  case VT_EMPTY:
   val = 0;
   break;
  default:
   val = vtFld.dblVal;
  }
  dbValue = val;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}


BOOL CADORecordset::GetFieldValue(int nIndex, double& dbValue)

 double val = (double)NULL;
 _variant_t vtFld;
 _variant_t vtIndex;

 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  switch(vtFld.vt)
  {
  case VT_R4:
   val = vtFld.fltVal;
   break;
  case VT_R8:
   val = vtFld.dblVal;
   break;
  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);
   break;
  case VT_UI1:
   val = vtFld.iVal;
   break;
  case VT_I2:
  case VT_I4:
   val = vtFld.lVal;
   break;
  case VT_INT:
   val = vtFld.intVal;
   break;
  case VT_NULL:
  case VT_EMPTY:
   val = 0;
   break;
  default:
   val = 0;
  }
  dbValue = val;
  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 vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
   val = vtFld.lVal;
  lValue = val;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(int nIndex, long& lValue)
{
 long val = (long)NULL;
 _variant_t vtFld;
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
   val = vtFld.lVal;
  lValue = val;
  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 vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
   val = vtFld.ulVal;
  ulValue = val;
  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 vtFld;
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
   val = vtFld.ulVal;
  ulValue = val;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, int& nValue)
{
 int val = NULL;
 _variant_t vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  switch(vtFld.vt)
  {
  case VT_BOOL:
   val = vtFld.boolVal;
   break;
  case VT_I2:
  case VT_UI1:
   val = vtFld.iVal;
   break;
  case VT_INT:
   val = vtFld.intVal;
   break;
  case VT_NULL:
  case VT_EMPTY:
   val = 0;
   break;
  default:
   val = vtFld.iVal;
  } 
  nValue = val;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(int nIndex, int& nValue)
{
 int val = (int)NULL;
 _variant_t vtFld;
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  switch(vtFld.vt)
  {
  case VT_BOOL:
   val = vtFld.boolVal;
   break;
  case VT_I2:
  case VT_UI1:
   val = vtFld.iVal;
   break;
  case VT_INT:
   val = vtFld.intVal;
   break;
  case VT_NULL:
  case VT_EMPTY:
   val = 0;
   break;
  default:
   val = vtFld.iVal;
  } 
  nValue = val;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, CString& strValue, CString strDateFormat)
{
 CString str = _T("");
 _variant_t vtFld;

 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  switch(vtFld.vt)
  {
  case VT_R4:
   str = DblToStr(vtFld.fltVal);
   break;
  case VT_R8:
   str = DblToStr(vtFld.dblVal);
   break;
  case VT_BSTR:
   str = vtFld.bstrVal;
   break;
  case VT_I2:
  case VT_UI1:
   str = IntToStr(vtFld.iVal);
   break;
  case VT_INT:
   str = IntToStr(vtFld.intVal);
   break;
  case VT_I4:
   str = LongToStr(vtFld.lVal);
   break;
  case VT_UI4:
   str = ULongToStr(vtFld.ulVal);
   break;
  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);
   }
   break;
  case VT_DATE:
   {
    COleDateTime dt(vtFld);

    if(strDateFormat.IsEmpty())
     strDateFormat = _T("%Y-%m-%d %H:%M:%S");
    str = dt.Format(strDateFormat);
   }
   break;
  case VT_EMPTY:
  case VT_NULL:
   str.Empty();
   break;
  case VT_BOOL:
   str = vtFld.boolVal == VARIANT_TRUE? 'T':'F';
   break;
  default:
   str.Empty();
   return FALSE;
  }
  strValue = str;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(int nIndex, CString& strValue, CString strDateFormat)
{
 CString str = _T("");
 _variant_t vtFld;
 _variant_t vtIndex;

 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  switch(vtFld.vt)
  {
  case VT_R4:
   str = DblToStr(vtFld.fltVal);
   break;
  case VT_R8:
   str = DblToStr(vtFld.dblVal);
   break;
  case VT_BSTR:
   str = vtFld.bstrVal;
   break;
  case VT_I2:
  case VT_UI1:
   str = IntToStr(vtFld.iVal);
   break;
  case VT_INT:
   str = IntToStr(vtFld.intVal);
   break;
  case VT_I4:
   str = LongToStr(vtFld.lVal);
   break;
  case VT_UI4:
   str = ULongToStr(vtFld.ulVal);
   break;
  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);
   }
   break;
  case VT_DATE:
   {
    COleDateTime dt(vtFld);
    
    if(strDateFormat.IsEmpty())
     strDateFormat = _T("%Y-%m-%d %H:%M:%S");
    str = dt.Format(strDateFormat);
   }
   break;
  case VT_BOOL:
   str = vtFld.boolVal == VARIANT_TRUE? 'T':'F';
   break;
  case VT_EMPTY:
  case VT_NULL:
   str.Empty();
   break;
  default:
   str.Empty();
   return FALSE;
  }
  strValue = str;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, COleDateTime& time)
{
 _variant_t vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  switch(vtFld.vt)
  {
  case VT_DATE:
   {
    COleDateTime dt(vtFld);
    time = dt;
   }
   break;
  case VT_EMPTY:
  case VT_NULL:
   time.SetStatus(COleDateTime::null);
   break;
  default:
   return FALSE;
  }
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(int nIndex, COleDateTime& time)
{
 _variant_t vtFld;
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  switch(vtFld.vt)
  {
  case VT_DATE:
   {
    COleDateTime dt(vtFld);
    time = dt;
   }
   break;
  case VT_EMPTY:
  case VT_NULL:
   time.SetStatus(COleDateTime::null);
   break;
  default:
   return FALSE;
  }
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, bool& bValue)
{
 _variant_t vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  switch(vtFld.vt)
  {
  case VT_BOOL:
   bValue = vtFld.boolVal == VARIANT_TRUE? true: false;
   break;
  case VT_EMPTY:
  case VT_NULL:
   bValue = false;
   break;
  default:
   return FALSE;
  }
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(int nIndex, bool& bValue)
{
 _variant_t vtFld;
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  switch(vtFld.vt)
  {
  case VT_BOOL:
   bValue = vtFld.boolVal == VARIANT_TRUE? true: false;
   break;
  case VT_EMPTY:
  case VT_NULL:
   bValue = false;
   break;
  default:
   return FALSE;
  }
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, COleCurrency& cyValue)
{
 _variant_t vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  switch(vtFld.vt)
  {
  case VT_CY:
   cyValue = (CURRENCY)vtFld.cyVal;
   break;
  case VT_EMPTY:
  case VT_NULL:
   {
   cyValue = COleCurrency();
   cyValue.m_status = COleCurrency::null;
   }
   break;
  default:
   return FALSE;
  }
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(int nIndex, COleCurrency& cyValue)
{
 _variant_t vtFld;
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  switch(vtFld.vt)
  {
  case VT_CY:
   cyValue = (CURRENCY)vtFld.cyVal;
   break;
  case VT_EMPTY:
  case VT_NULL:
   {
   cyValue = COleCurrency();
   cyValue.m_status = COleCurrency::null;
   }
   break;
  default:
   return FALSE;
  }
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, _variant_t& vtValue)
{
 try
 {
  vtValue = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::GetFieldValue(int nIndex, _variant_t& vtValue)
{
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtValue = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::IsFieldNull(LPCTSTR lpFieldName)
{
 _variant_t vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  return vtFld.vt == VT_NULL;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::IsFieldNull(int nIndex)
{
 _variant_t vtFld;
 _variant_t vtIndex;

 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  return vtFld.vt == VT_NULL;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::IsFieldEmpty(LPCTSTR lpFieldName)
{
 _variant_t vtFld;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
  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 vtFld;
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 try
 {
  vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
  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 vtFld;
 vtFld.vt = VT_EMPTY;
 
 return PutFieldValue(lpFieldName, vtFld);
}

BOOL CADORecordset::SetFieldEmpty(int nIndex)
{
 _variant_t vtFld;
 vtFld.vt = VT_EMPTY;

 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 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)
  {
   nRows++;
   m_pRecordset->MoveNext();
  }
  if(nRows > 0)
   m_pRecordset->MoveFirst();
 }
 
 return nRows;
}

BOOL CADORecordset::IsOpen()
{
 if(m_pRecordset != NULL && IsConnectionOpen())
  return m_pRecordset->GetState() != adStateClosed;
 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 vRecords;
 
 m_nRecordsAffected = 0;

 try
 {
  m_pConnection->CursorLocation = adUseClient;
  m_pConnection->Execute(_bstr_t(lpstrExec), &vRecords, adExecuteNoRecords);
  m_nRecordsAffected = vRecords.iVal;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE; 
 }
}

BOOL CADORecordset::RecordBinding(CADORecordBinding &pAdoRecordBinding)
{
 HRESULT hr;
 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* fldInfo)
{
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 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& strValue)
{
 FieldPtr pField = m_pRecordset->Fields->GetItem(lpFieldName);
 
 return GetChunk(pField, strValue);
}

BOOL CADORecordset::GetChunk(int nIndex, CString& strValue)
{
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 FieldPtr pField = m_pRecordset->Fields->GetItem(vtIndex);
 
 return GetChunk(pField, strValue);
}


BOOL CADORecordset::GetChunk(FieldPtr pField, CString& strValue)
{
 CString str = _T("");
 long lngSize, lngOffSet = 0;
 _variant_t varChunk;

 lngSize = pField->ActualSize;
 
 str.Empty();
 while(lngOffSet < lngSize)
 {
  try
  {
   varChunk = pField->GetChunk(ChunkSize);
   
   str += varChunk.bstrVal;
   lngOffSet += ChunkSize;
  }
  catch(_com_error &e)
  {
   dump_com_error(e);
   return FALSE;
  }
 }

 lngOffSet = 0;
 strValue = str;
 return TRUE;
}

BOOL CADORecordset::GetChunk(LPCTSTR lpFieldName, LPVOID lpData)
{
 FieldPtr pField = m_pRecordset->Fields->GetItem(lpFieldName);

 return GetChunk(pField, lpData);
}

BOOL CADORecordset::GetChunk(int nIndex, LPVOID lpData)
{
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 FieldPtr pField = m_pRecordset->Fields->GetItem(vtIndex);

 return GetChunk(pField, lpData);
}

BOOL CADORecordset::GetChunk(FieldPtr pField, LPVOID lpData)
{
 long lngSize, lngOffSet = 0;
 _variant_t varChunk;   
 UCHAR chData;
 HRESULT hr;
 long lBytesCopied = 0;

 lngSize = pField->ActualSize;
 
 while(lngOffSet < lngSize)
 {
  try
  {
   varChunk = pField->GetChunk(ChunkSize);

   //Copy the data only upto the Actual Size of Field. 
            for(long lIndex = 0; lIndex <= (ChunkSize - 1); lIndex++)
            {
                hr= SafeArrayGetElement(varChunk.parray, &lIndex, &chData);
                if(SUCCEEDED(hr))
                {
                    //Take BYTE by BYTE and advance Memory Location
                    //hr = SafeArrayPutElement((SAFEARRAY FAR*)lpData, &lBytesCopied ,&chData);
     ((UCHAR*)lpData)[lBytesCopied] = chData;
                    lBytesCopied++;
                }
                else
                    break;
            }
   lngOffSet += ChunkSize;
  }
  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 vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 FieldPtr pField = m_pRecordset->Fields->GetItem(vtIndex);

 return AppendChunk(pField, lpData, nBytes);
}

BOOL CADORecordset::AppendChunk(FieldPtr pField, LPVOID lpData, UINT nBytes)
{
 HRESULT hr;
 _variant_t varChunk;
 long lngOffset = 0;
 UCHAR chData;
 SAFEARRAY FAR *psa = NULL;
 SAFEARRAYBOUND rgsabound[1];

 try
 {
  //Create a safe array to store the array of BYTES
  rgsabound[0].lLbound = 0;
  rgsabound[0].cElements = nBytes;
  psa = SafeArrayCreate(VT_UI1,1,rgsabound);

  while(lngOffset < (long)nBytes)
  {
   chData = ((UCHAR*)lpData)[lngOffset];
   hr = SafeArrayPutElement(psa, &lngOffset, &chData);

   if(FAILED(hr))
    return FALSE;
   
   lngOffset++;
  }
  lngOffset = 0;

  //Assign the Safe array  to a variant.
  varChunk.vt = VT_ARRAY|VT_UI1;
  varChunk.parray = psa;

  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 varOutput;
 _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)varOutput;
}

CString IntToStr(int nVal)
{
 CString strRet;
 char buff[10];
 
 itoa(nVal, buff, 10);
 strRet = buff;
 return strRet;
}

CString LongToStr(long lVal)
{
 CString strRet;
 char buff[20];
 
 ltoa(lVal, buff, 10);
 strRet = buff;
 return strRet;
}

CString ULongToStr(unsigned long ulVal)
{
 CString strRet;
 char buff[20];
 
 ultoa(ulVal, buff, 10);
 strRet = buff;
 return strRet;

}


CString DblToStr(double dblVal, int ndigits)
{
 CString strRet;
 char buff[50];

   _gcvt(dblVal, ndigits, buff);
 strRet = buff;
 return strRet;
}

CString DblToStr(float fltVal)
{
 CString strRet = _T("");
 char buff[50];
 
   _gcvt(fltVal, 10, buff);
 strRet = buff;
 return strRet;
}

void CADORecordset::Edit()
{
 m_nEditStatus = dbEdit;
}

BOOL CADORecordset::AddNew()
{
 m_nEditStatus = dbEditNone;
 if(m_pRecordset->AddNew() != S_OK)
  return FALSE;

 m_nEditStatus = dbEditNew;
 return TRUE;
}

BOOL CADORecordset::AddNew(CADORecordBinding &pAdoRecordBinding)
{
 try
 {
  if(m_pRecBinding->AddNew(&pAdoRecordBinding) != S_OK)
  {
   return FALSE;
  }
  else
  {
   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)
 {

  try
  {
   if(m_pRecordset->Update() != S_OK)
    bret = FALSE;
  }
  catch(_com_error &e)
  {
   dump_com_error(e);
   bret = FALSE;
  }

  if(!bret)
   m_pRecordset->CancelUpdate();
  m_nEditStatus = dbEditNone;
 }
 return bret;
}

void CADORecordset::CancelUpdate()
{
 m_pRecordset->CancelUpdate();
 m_nEditStatus = dbEditNone;
}

BOOL CADORecordset::SetFieldValue(int nIndex, CString strValue)
{
 _variant_t vtFld;
 _variant_t vtIndex; 
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 if(!strValue.IsEmpty())
  vtFld.vt = VT_BSTR;
 else
  vtFld.vt = VT_NULL;

 //Corrected by Giles Forster 10/03/2001
 vtFld.bstrVal = strValue.AllocSysString();

 return PutFieldValue(vtIndex, vtFld);
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, CString strValue)
{
 _variant_t vtFld;

 if(!strValue.IsEmpty())
  vtFld.vt = VT_BSTR;
 else
  vtFld.vt = VT_NULL;

 //Corrected by Giles Forster 10/03/2001
 vtFld.bstrVal = strValue.AllocSysString();

 return PutFieldValue(lpFieldName, vtFld);
}

BOOL CADORecordset::SetFieldValue(int nIndex, int nValue)
{
 _variant_t vtFld;
 
 vtFld.vt = VT_I2;
 vtFld.iVal = nValue;
 
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 return PutFieldValue(vtIndex, vtFld);
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, int nValue)
{
 _variant_t vtFld;
 
 vtFld.vt = VT_I2;
 vtFld.iVal = nValue;
 
 
 return PutFieldValue(lpFieldName, vtFld);
}

BOOL CADORecordset::SetFieldValue(int nIndex, long lValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_I4;
 vtFld.lVal = lValue;
 
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 return PutFieldValue(vtIndex, vtFld);
 
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, long lValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_I4;
 vtFld.lVal = lValue;
 
 return PutFieldValue(lpFieldName, vtFld);
}

BOOL CADORecordset::SetFieldValue(int nIndex, unsigned long ulValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_UI4;
 vtFld.ulVal = ulValue;
 
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 return PutFieldValue(vtIndex, vtFld);
 
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, unsigned long ulValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_UI4;
 vtFld.ulVal = ulValue;
 
 return PutFieldValue(lpFieldName, vtFld);
}

BOOL CADORecordset::SetFieldValue(int nIndex, double dblValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_R8;
 vtFld.dblVal = dblValue;

 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;

 return PutFieldValue(vtIndex, vtFld);
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, double dblValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_R8;
 vtFld.dblVal = dblValue;
  
 return PutFieldValue(lpFieldName, vtFld);
}

BOOL CADORecordset::SetFieldValue(int nIndex, COleDateTime time)
{
 _variant_t vtFld;
 vtFld.vt = VT_DATE;
 vtFld.date = time;
 
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 return PutFieldValue(vtIndex, vtFld);
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, COleDateTime time)
{
 _variant_t vtFld;
 vtFld.vt = VT_DATE;
 vtFld.date = time;
 
 return PutFieldValue(lpFieldName, vtFld);
}

 

BOOL CADORecordset::SetFieldValue(int nIndex, bool bValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_BOOL;
 vtFld.boolVal = bValue;
 
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 return PutFieldValue(vtIndex, vtFld);
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, bool bValue)
{
 _variant_t vtFld;
 vtFld.vt = VT_BOOL;
 vtFld.boolVal = bValue;
 
 return PutFieldValue(lpFieldName, vtFld);
}


BOOL CADORecordset::SetFieldValue(int nIndex, COleCurrency cyValue)
{
 if(cyValue.m_status == COleCurrency::invalid)
  return FALSE;

 _variant_t vtFld;
  
 vtFld.vt = VT_CY;
 vtFld.cyVal = cyValue.m_cur;
 
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 return PutFieldValue(vtIndex, vtFld);
}

BOOL CADORecordset::SetFieldValue(LPCTSTR lpFieldName, COleCurrency cyValue)
{
 if(cyValue.m_status == COleCurrency::invalid)
  return FALSE;

 _variant_t vtFld;

 vtFld.vt = VT_CY;
 vtFld.cyVal = cyValue.m_cur; 
  
 return PutFieldValue(lpFieldName, vtFld);
}

BOOL CADORecordset::SetFieldValue(int nIndex, _variant_t vtValue)
{
 _variant_t vtIndex;
 
 vtIndex.vt = VT_I2;
 vtIndex.iVal = nIndex;
 
 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_varBookmark;
  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 = dbEditNone;
 return TRUE;
}

BOOL CADORecordset::Find(LPCTSTR lpFind, int nSearchDirection)
{

 m_strFind = lpFind;
 m_nSearchDirection = nSearchDirection;

 ASSERT(!m_strFind.IsEmpty());

 if(m_nSearchDirection == searchForward)
 {
  m_pRecordset->Find(_bstr_t(m_strFind), 0, adSearchForward, "");
  if(!IsEof())
  {
   m_varBookFind = m_pRecordset->Bookmark;
   return TRUE;
  }
 }
 else if(m_nSearchDirection == searchBackward)
 {
  m_pRecordset->Find(_bstr_t(m_strFind), 0, adSearchBackward, "");
  if(!IsBof())
  {
   m_varBookFind = m_pRecordset->Bookmark;
   return TRUE;
  }
 }
 else
 {
  TRACE("Unknown parameter. %d", nSearchDirection);
  m_nSearchDirection = searchForward;
 }
 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->Bookmark;
   return TRUE;
  }
 }
 else
 {
  m_pRecordset->Find(_bstr_t(m_strFind), 1, adSearchBackward, m_varBookFind);
  if(!IsBof())
  {
   m_varBookFind = m_pRecordset->Bookmark;
   return TRUE;
  }
 }
 return FALSE;
}

BOOL CADORecordset::PutFieldValue(LPCTSTR lpFieldName, _variant_t vtFld)
{
 if(m_nEditStatus == dbEditNone)
  return FALSE;
 
 try
 {
  m_pRecordset->Fields->GetItem(lpFieldName)->Value = vtFld;
  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;

 try
 {
  m_pRecordset->Fields->GetItem(vtIndex)->Value = vtFld;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::Clone(CADORecordset &pRs)
{
 try
 {
  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());
 
 try
 {
  m_pRecordset->PutFilter(strFilter);
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::SetSort(LPCTSTR strCriteria)
{
 ASSERT(IsOpen());
 
 try
 {
  m_pRecordset->PutSort(strCriteria);
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::SaveAsXML(LPCTSTR lpstrXMLFile)
{
 HRESULT hr;

 ASSERT(IsOpen());
 
 try
 {
  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())
  Close();

 try
 {
  hr = m_pRecordset->Open(lpstrXMLFile, "Provider=MSPersist;", adOpenForwardOnly, adLockOptimistic, adCmdFile);
  return hr == S_OK;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADORecordset::Execute(CADOCommand* pAdoCommand)
{
 if(IsOpen())
  Close();

 ASSERT(!pAdoCommand->GetText().IsEmpty());
 try
 {
  m_pConnection->CursorLocation = adUseClient;
  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 ErrorStr;
 
 
 _bstr_t bstrSource(e.Source());
 _bstr_t bstrDescription(e.Description());
 ErrorStr.Format( "CADORecordset Error/n/tCode = %08lx/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 );
 #endif 
}


///////////////////////////////////////////////////////
//
// CADOCommad Class
//

CADOCommand::CADOCommand(CADODatabase* pAdoDatabase, CString strCommandText, int nCommandType)
{
 m_pCommand = NULL;
 m_pCommand.CreateInstance(__uuidof(Command));
 m_strCommandText = strCommandText;
 m_pCommand->CommandText = m_strCommandText.AllocSysString();
 m_nCommandType = nCommandType;
 m_pCommand->CommandType = (CommandTypeEnum)m_nCommandType;
 m_pCommand->ActiveConnection = pAdoDatabase->GetActiveConnection(); 
 m_nRecordsAffected = 0;
}

BOOL CADOCommand::AddParameter(CADOParameter* pAdoParameter)
{
 ASSERT(pAdoParameter->GetParameter() != NULL);

 try
 {
  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 vtValue;

 vtValue.vt = VT_I2;
 vtValue.iVal = nValue;

 return AddParameter(strName, nType, nDirection, lSize, vtValue);
}

BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, long lValue)
{

 _variant_t vtValue;

 vtValue.vt = VT_I4;
 vtValue.lVal = lValue;

 return AddParameter(strName, nType, nDirection, lSize, vtValue);
}

BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, double dblValue, int nPrecision, int nScale)
{

 _variant_t vtValue;

 vtValue.vt = VT_R8;
 vtValue.dblVal = dblValue;

 return AddParameter(strName, nType, nDirection, lSize, vtValue, nPrecision, nScale);
}

BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, CString strValue)
{

 _variant_t vtValue;

 vtValue.vt = VT_BSTR;
 vtValue.bstrVal = strValue.AllocSysString();

 return AddParameter(strName, nType, nDirection, lSize, vtValue);
}

BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, COleDateTime time)
{

 _variant_t vtValue;

 vtValue.vt = VT_DATE;
 vtValue.date = time;

 return AddParameter(strName, nType, nDirection, lSize, vtValue);
}


BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, _variant_t vtValue, int nPrecision, int nScale)
{
 try
 {
  _ParameterPtr pParam = m_pCommand->CreateParameter(strName.AllocSysString(), (DataTypeEnum)nType, (ParameterDirectionEnum)nDirection, lSize, vtValue);
  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 = strCommandText;
 m_pCommand->CommandText = m_strCommandText.AllocSysString();
}

void CADOCommand::SetType(int nCommandType)
{
 m_nCommandType = nCommandType;
 m_pCommand->CommandType = (CommandTypeEnum)m_nCommandType;
}

BOOL CADOCommand::Execute()
{
 _variant_t vRecords;
 m_nRecordsAffected = 0;
 try
 {
  m_pCommand->Execute(&vRecords, NULL, adCmdStoredProc);
  m_nRecordsAffected = vRecords.iVal;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

void CADOCommand::dump_com_error(_com_error &e)
{
 CString ErrorStr;
 
 
 _bstr_t bstrSource(e.Source());
 _bstr_t bstrDescription(e.Description());
 ErrorStr.Format( "CADOCommand Error/n/tCode = %08lx/n/tCode meaning = %s/n/tSource = %s/n/tDescription = %s/n",
  e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource, (LPCSTR)bstrDescription );
 m_strLastError = ErrorStr;
 m_dwLastError = e.Error();
 #ifdef _DEBUG
  AfxMessageBox(ErrorStr, MB_OK | MB_ICONERROR);
 #endif 
}


///////////////////////////////////////////////////////
//
// 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)nDirection;
 m_strName = strName;
 m_pParameter->Name = m_strName.AllocSysString();
 m_pParameter->Type = (DataTypeEnum)nType;
 m_pParameter->Size = lSize;
 m_nType = nType;
}

BOOL CADOParameter::SetValue(int nValue)
{
 _variant_t vtVal;

 ASSERT(m_pParameter != NULL);
 
 vtVal.vt = VT_I2;
 vtVal.iVal = nValue;

 try
 {
  if(m_pParameter->Size == 0)
   m_pParameter->Size = sizeof(int);

  m_pParameter->Value = vtVal;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}


BOOL CADOParameter::SetValue(long lValue)
{
 _variant_t vtVal;

 ASSERT(m_pParameter != NULL);
 
 vtVal.vt = VT_I4;
 vtVal.lVal = lValue;

 try
 {
  if(m_pParameter->Size == 0)
   m_pParameter->Size = sizeof(long);

  m_pParameter->Value = vtVal;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::SetValue(double dblValue)
{
 _variant_t vtVal;

 ASSERT(m_pParameter != NULL);
 
 vtVal.vt = VT_R8;
 vtVal.dblVal = dblValue;

 try
 {
  if(m_pParameter->Size == 0)
   m_pParameter->Size = sizeof(double);

  m_pParameter->Value = vtVal;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::SetValue(CString strValue)
{
 _variant_t vtVal;

 ASSERT(m_pParameter != NULL);
 
 if(!strValue.IsEmpty())
  vtVal.vt = VT_BSTR;
 else
  vtVal.vt = VT_NULL;

 //Corrected by Giles Forster 10/03/2001
 vtVal.bstrVal = strValue.AllocSysString();

 try
 {
  if(m_pParameter->Size == 0)
   m_pParameter->Size = sizeof(char) * strValue.GetLength();

  m_pParameter->Value = vtVal;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::SetValue(COleDateTime time)
{
 _variant_t vtVal;

 ASSERT(m_pParameter != NULL);
 
 vtVal.vt = VT_DATE;
 vtVal.date = time;

 try
 {
  if(m_pParameter->Size == 0)
   m_pParameter->Size = sizeof(DATE);

  m_pParameter->Value = vtVal;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::SetValue(_variant_t vtValue)
{

 ASSERT(m_pParameter != NULL);

 try
 {
  if(m_pParameter->Size == 0)
   m_pParameter->Size = sizeof(VARIANT);
  
  m_pParameter->Value = vtValue;
  return TRUE;
 }
 catch(_com_error &e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::GetValue(int& nValue)
{
 _variant_t vtVal;
 int nVal = 0;

 try
 {
  vtVal = m_pParameter->Value;

  switch(vtVal.vt)
  {
  case VT_BOOL:
   nVal = vtVal.boolVal;
   break;
  case VT_I2:
  case VT_UI1:
   nVal = vtVal.iVal;
   break;
  case VT_INT:
   nVal = vtVal.intVal;
   break;
  case VT_NULL:
  case VT_EMPTY:
   nVal = 0;
   break;
  default:
   nVal = vtVal.iVal;
  } 
  nValue = nVal;
  return TRUE;
 }
 catch(_com_error& e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::GetValue(long& lValue)
{
 _variant_t vtVal;
 long lVal = 0;

 try
 {
  vtVal = m_pParameter->Value;
  if(vtVal.vt != VT_NULL && vtVal.vt != VT_EMPTY)
   lVal = vtVal.lVal;
  lValue = lVal;
  return TRUE;
 }
 catch(_com_error& e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::GetValue(double& dbValue)
{
 _variant_t vtVal;
 double dblVal;
 try
 {
  vtVal = m_pParameter->Value;
  switch(vtVal.vt)
  {
  case VT_R4:
   dblVal = vtVal.fltVal;
   break;
  case VT_R8:
   dblVal = vtVal.dblVal;
   break;
  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);
   break;
  case VT_UI1:
   dblVal = vtVal.iVal;
   break;
  case VT_I2:
  case VT_I4:
   dblVal = vtVal.lVal;
   break;
  case VT_INT:
   dblVal = vtVal.intVal;
   break;
  case VT_NULL:
  case VT_EMPTY:
   dblVal = 0;
   break;
  default:
   dblVal = 0;
  }
  dbValue = dblVal;
  return TRUE;
 }
 catch(_com_error& e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::GetValue(CString& strValue, CString strDateFormat)
{
 _variant_t vtVal;
 CString strVal = _T("");

 try
 {
  vtVal = m_pParameter->Value;
  switch(vtVal.vt)
  {
  case VT_R4:
   strVal = DblToStr(vtVal.fltVal);
   break;
  case VT_R8:
   strVal = DblToStr(vtVal.dblVal);
   break;
  case VT_BSTR:
   strVal = vtVal.bstrVal;
   break;
  case VT_I2:
  case VT_UI1:
   strVal = IntToStr(vtVal.iVal);
   break;
  case VT_INT:
   strVal = IntToStr(vtVal.intVal);
   break;
  case VT_I4:
   strVal = LongToStr(vtVal.lVal);
   break;
  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);
   }
   break;
  case VT_DATE:
   {
    COleDateTime dt(vtVal);

    if(strDateFormat.IsEmpty())
     strDateFormat = _T("%Y-%m-%d %H:%M:%S");
    strVal = dt.Format(strDateFormat);
   }
   break;
  case VT_EMPTY:
  case VT_NULL:
   strVal.Empty();
   break;
  default:
   strVal.Empty();
   return FALSE;
  }
  strValue = strVal;
  return TRUE;
 }
 catch(_com_error& e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::GetValue(COleDateTime& time)
{
 _variant_t vtVal;

 try
 {
  vtVal = m_pParameter->Value;
  switch(vtVal.vt)
  {
  case VT_DATE:
   {
    COleDateTime dt(vtVal);
    time = dt;
   }
   break;
  case VT_EMPTY:
  case VT_NULL:
   time.SetStatus(COleDateTime::null);
   break;
  default:
   return FALSE;
  }
  return TRUE;
 }
 catch(_com_error& e)
 {
  dump_com_error(e);
  return FALSE;
 }
}

BOOL CADOParameter::GetValue(_variant_t& vtValue)
{
 try
 {
  vtValue = m_pParameter->Value;
  return TRUE;
 }
 catch(_com_error& e)
 {
  dump_com_error(e);
  return FALSE;
 }
}


void CADOParameter::dump_com_error(_com_error &e)
{
 CString ErrorStr;
 
 
 _bstr_t bstrSource(e.Source());
 _bstr_t bstrDescription(e.Description());
 ErrorStr.Format( "CADOParameter Error/n/tCode = %08lx/n/tCode meaning = %s/n/tSource = %s/n/tDescription = %s/n",
  e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource, (LPCSTR)bstrDescription );
 m_strLastError = ErrorStr;
 m_dwLastError = e.Error();
 #ifdef _DEBUG
  AfxMessageBox(ErrorStr, MB_OK | MB_ICONERROR);
 #endif 
}

IMPLEMENT_DYNAMIC(CADOException, CException)

CADOException::CADOException(int nCause, CString strErrorString) : CException(TRUE)
{
 m_nCause = nCause;
 m_strErrorString = strErrorString;
}

CADOException::~CADOException()
{

}

int CADOException::GetError(int nADOError)
{
 switch (nADOError)
 {
 case noError:
  return CADOException::noError;
  break;
 default:
  return CADOException::Unknown;
 }
 
}

void AfxThrowADOException(int nADOError, CString strErrorString)
{
 throw new CADOException(nADOError, strErrorString);
}

///////////////Ado.h
//
//  MODULE: Ado.h
//
// AUTHOR: Carlos Antollini
//
//  mailto: cantollini@hotmail.com
//
// Date: 11/19/2002
//
// Version 2.09
//

#ifndef _ADO_H_
#define _ADO_H_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
#include <afx.h>
#include <afxdisp.h>
#include <math.h>

#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
#import "c:/Program Files/Common Files/System/ADO/msado15.dll" rename_namespace("ADOCG") rename("EOF", "EndOfFile")
using namespace ADOCG;

#pragma warning (default: 4146)

#include "icrsint.h"


class CADOCommand;

struct CADOFieldInfo
{
 char m_strName[30];
 short m_nType;
 long m_lSize;
 long m_lDefinedSize;
 long m_lAttributes;
 short m_nOrdinalPosition;
 BOOL m_bRequired;  
 BOOL m_bAllowZeroLength;
 long m_lCollatingOrder; 
};

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 CADODatabase
{
public:
 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()
 {
  Close();
  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_pConnection;};
 BOOL Execute(LPCTSTR lpstrExec);
 int GetRecordsAffected()
  {return m_nRecordsAffected;};
 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 = lpstrConnection;};
 CString GetConnectionString()
  {return m_strConnection;};
 CString GetLastErrorString()
  {return m_strLastError;};
 DWORD GetLastError()
  {return m_dwLastError;};
 CString GetErrorDescription()
  {return m_strErrorDescription;};
 void SetConnectionTimeout(long nConnectionTimeout = 30)
  {m_nConnectionTimeout = nConnectionTimeout;};

protected:
 void dump_com_error(_com_error &e);

public:
 _ConnectionPtr m_pConnection;

protected:
 CString m_strConnection;
 CString m_strLastError;
 CString m_strErrorDescription;
 DWORD m_dwLastError;
 int m_nRecordsAffected;
 long m_nConnectionTimeout;
};

class CADORecordset
{
public:
 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 = adEmpty,
  typeTinyInt = adTinyInt,
  typeSmallInt = adSmallInt,
  typeInteger = adInteger,
  typeBigInt = adBigInt,
  typeUnsignedTinyInt = adUnsignedTinyInt,
  typeUnsignedSmallInt = adUnsignedSmallInt,
  typeUnsignedInt = adUnsignedInt,
  typeUnsignedBigInt = adUnsignedBigInt,
  typeSingle = adSingle,
  typeDouble = adDouble,
  typeCurrency = adCurrency,
  typeDecimal = adDecimal,
  typeNumeric = adNumeric,
  typeBoolean = adBoolean,
  typeError = adError,
  typeUserDefined = adUserDefined,
  typeVariant = adVariant,
  typeIDispatch = adIDispatch,
  typeIUnknown = adIUnknown,
  typeGUID = adGUID,
  typeDate = adDate,
  typeDBDate = adDBDate,
  typeDBTime = adDBTime,
  typeDBTimeStamp = adDBTimeStamp,
  typeBSTR = adBSTR,
  typeChar = adChar,
  typeVarChar = adVarChar,
  typeLongVarChar = adLongVarChar,
  typeWChar = adWChar,
  typeVarWChar = adVarWChar,
  typeLongVarWChar = adLongVarWChar,
  typeBinary = adBinary,
  typeVarBinary = adVarBinary,
  typeLongVarBinary = adLongVarBinary,
  typeChapter = adChapter,
  typeFileTime = adFileTime,
  typePropVariant = adPropVariant,
  typeVarNumeric = adVarNumeric,
  typeArray = 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,
  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 lValue);
 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 time);
 BOOL SetFieldValue(int nIndex, bool bValue);
 BOOL SetFieldValue(LPCTSTR lpFieldName, bool bValue);
 BOOL SetFieldValue(int nIndex, COleCurrency cyValue);
 BOOL SetFieldValue(LPCTSTR lpFieldName, COleCurrency cyValue);
 BOOL SetFieldValue(int nIndex, _variant_t vtValue);
 BOOL SetFieldValue(LPCTSTR lpFieldName, _variant_t vtValue);

 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()
 {
  Close();
  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 = dbEditNone;
 }

 CString GetQuery()
  {return m_strQuery;};
 void SetQuery(LPCSTR strQuery)
  {m_strQuery = strQuery;};
 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& nValue);
 BOOL GetFieldValue(int nIndex, int& nValue);
 BOOL GetFieldValue(LPCTSTR lpFieldName, long& lValue);
 BOOL GetFieldValue(int nIndex, long& lValue);
 BOOL GetFieldValue(LPCTSTR lpFieldName, unsigned long& ulValue);
 BOOL GetFieldValue(int nIndex, unsigned long& ulValue);
 BOOL GetFieldValue(LPCTSTR lpFieldName, double& dbValue);
 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& time);
 BOOL GetFieldValue(int nIndex, COleDateTime& time);
 BOOL GetFieldValue(int nIndex, bool& bValue);
 BOOL GetFieldValue(LPCTSTR lpFieldName, bool& bValue);
 BOOL GetFieldValue(int nIndex, COleCurrency& cyValue);
 BOOL GetFieldValue(LPCTSTR lpFieldName, COleCurrency& cyValue);
 BOOL GetFieldValue(int nIndex, _variant_t& vtValue);
 BOOL GetFieldValue(LPCTSTR lpFieldName, _variant_t& vtValue);
 
 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* fldInfo);
 BOOL GetFieldInfo(int nIndex, CADOFieldInfo* fldInfo);
 BOOL AppendChunk(LPCTSTR lpFieldName, LPVOID lpData, UINT nBytes);
 BOOL AppendChunk(int nIndex, LPVOID lpData, UINT nBytes);

 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_strLastError;};
 DWORD GetLastError()
  {return m_dwLastError;};
 void GetBookmark()
  {m_varBookmark = m_pRecordset->Bookmark;};
 BOOL SetBookmark();
 BOOL Delete();
 BOOL IsConnectionOpen()
  {return m_pConnection != NULL && m_pConnection->GetState() != adStateClosed;};
 _RecordsetPtr GetRecordset()
  {return m_pRecordset;};
 _ConnectionPtr GetActiveConnection()
  {return m_pConnection;};

 BOOL SetFilter(LPCTSTR strFilter);
 BOOL SetSort(LPCTSTR lpstrCriteria);
 BOOL SaveAsXML(LPCTSTR lpstrXMLFile);
 BOOL OpenXML(LPCTSTR lpstrXMLFile);
 BOOL Execute(CADOCommand* pCommand);
 BOOL Requery();

public:
 _RecordsetPtr m_pRecordset;
 _CommandPtr m_pCmd;
 
protected:
 _ConnectionPtr m_pConnection;
 int m_nSearchDirection;
 CString m_strFind;
 _variant_t m_varBookFind;
 _variant_t m_varBookmark;
 int m_nEditStatus;
 CString m_strLastError;
 DWORD m_dwLastError;
 void dump_com_error(_com_error &e);
 IADORecordBinding *m_pRecBinding;
 CString m_strQuery;

protected:
 BOOL PutFieldValue(LPCTSTR lpFieldName, _variant_t vtFld);
 BOOL PutFieldValue(_variant_t vtIndex, _variant_t vtFld);
 BOOL GetFieldInfo(FieldPtr pField, CADOFieldInfo* fldInfo);
 BOOL GetChunk(FieldPtr pField, CString& strValue);
 BOOL GetChunk(FieldPtr pField, LPVOID lpData);
 BOOL AppendChunk(FieldPtr pField, LPVOID lpData, UINT nBytes);
  
};

class CADOParameter
{
public:

 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 = _T(""));
 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 = strName;};
 CString GetName()
  {return m_strName;};
 int GetType()
  {return m_nType;};
 _ParameterPtr GetParameter()
  {return m_pParameter;};

protected:
 void dump_com_error(_com_error &e);
 
protected:
 _ParameterPtr m_pParameter;
 CString m_strName;
 int m_nType;
 CString m_strLastError;
 DWORD m_dwLastError;
};

class CADOCommand
{
public:
 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()
 {
  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_nCommandType;};
 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 = 0);
 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 = 0);
 CString GetText()
  {return m_strCommandText;};
 BOOL Execute();
 int GetRecordsAffected()
  {return m_nRecordsAffected;};
 _CommandPtr GetCommand()
  {return m_pCommand;};

protected:
 void dump_com_error(_com_error &e);

protected:
 _CommandPtr m_pCommand;
 int m_nCommandType;
 int m_nRecordsAffected;
 CString m_strCommandText;
 CString m_strLastError;
 DWORD m_dwLastError;
};

class CADOException : public CException
{
public:

 enum
 {
  noError, // no error
  Unknown, // unknown error
 };

 DECLARE_DYNAMIC(CADOException);
 
 CADOException(int nCause = 0, CString strErrorString = _T(""));
 virtual ~CADOException();

 static int GetError(int nADOError);

public:
 int m_nCause;
  CString m_strErrorString;
 
protected:
 
};

void AfxThrowADOException(int nADOError = 1000, CString strErrorString = _T(""));

#endif
/////////使用例子
//创建
CString strConnection = _T("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=userdb.mdb");
 g_pDb = new CADODatabase;
 g_pDb->Open(strConnection);

//使用
CADORecordset* pRs = new CADORecordset(App::g_pDb);
 if(pRs->Open((LPCTSTR)"SELECT *  FROM product"))
 {
  CString TempSql;
  while(!pRs->IsEOF())
  {
   pRs->GetFieldValue("title",TempSql);
   m_edit1=m_edit1+"|" + TempSql;
   
   //sortnum
   pRs->GetFieldValue("sortnum",TempSql);
   m_edit1=m_edit1+"," + TempSql;

   pRs->MoveNext();
  } 
  pRs->Close();
  UpdateData(false);
 }
 else
  AfxMessageBox("记录集创建失败");
 delete pRs; 

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

VC++操作数据库ADO封装类

  • 2016-12-24 10:40
  • 28KB
  • 下载

VC++下ADO数据库操作的封装类

一、ADO 对象 对象 说明 Command Command 对象定义了将对数据源执行的指定命令。 Connection ...

ADO操作类(C++版)

  • 2008-11-21 19:15
  • 109KB
  • 下载

MFC 和 数据库Access 用 Ado类 操作

暑假短学期一直在做

ADO操作数据库强大封装类

  • 2013-11-06 00:59
  • 420KB
  • 下载

C#集合篇,在业务背景下(***产品升级管理):依赖注入,变量声明,三元表达式,常用字符串相关操作方法,ADO.NET,EF机制,T4模板自动生成实体类,ref变量巧用,属性实际运用,唯一性验证

QQ:1187362408 欢迎技术交流和学习 关于系统产品升级报告管理,业务需求: TODO: 1,升级报告管理:依据各县区制定升级报告(关联sAreaCode,给每个地区观看具体升级报告信息...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)