adopack.cpp

ＡＤＯ封装类

#include "stdafx.h"
#include "adoPack.h"
#define ChunkSize 100

namespace adoPack
{

	/************************************************************************/
	/* CADOConnection
	/************************************************************************/
	CADOConnection::CADOConnection()
	{
		::CoInitialize(NULL);
		m_pConn = NULL;
		m_pConn.CreateInstance(__uuidof(Connection));

		m_strConnection = _T("");
		m_strLastError = _T("");
		m_dwLastError = 0;
		m_nRecordsAffected = 0;
		m_nConnectionTimeout = 0;
	}
	CADOConnection::~CADOConnection()
	{
		CloseConnection();
		m_pConn.Release();
		::CoUninitialize();

		m_pConn = NULL;
		m_strConnection = _T("");
		m_strLastError = _T("");
		m_dwLastError = 0;
	}

	DWORD CADOConnection::GetRecordCount(_RecordsetPtr pRS)
	{
		DWORD numRows = 0;
		numRows = pRS->GetRecordCount();

		if(numRows == -1)
		{
			if(pRS->EndOfFile != VARIANT_TRUE)
				pRS->MoveFirst();

			while(pRS->EndOfFile != VARIANT_TRUE)
			{
				numRows++;
				pRS->MoveNext();
			}
			if(numRows > 0)
				pRS->MoveFirst();
		}
		return numRows;
	}

	BOOL CADOConnection::OpenConnection(LPCTSTR lpstrConnection, LPCTSTR lpstrUserID, LPCTSTR lpstrPassword)
	{
		HRESULT hr = S_OK;

		if(IsConnectionOpened())
			CloseConnection();

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

		ASSERT(!m_strConnection.IsEmpty());

		try
		{
			if(m_nConnectionTimeout != 0)
				m_pConn->PutConnectionTimeout(m_nConnectionTimeout);
			hr = m_pConn->Open(_bstr_t(m_strConnection), _bstr_t(lpstrUserID), _bstr_t(lpstrPassword), NULL);
			return hr == S_OK;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}

	}

	

	BOOL CADOConnection::ExecuteSQL(LPCTSTR lpstrExec)
	{
		ASSERT(m_pConn != NULL);
		ASSERT(strcmp(lpstrExec, _T("")) != 0);
		_variant_t vRecords;

		m_nRecordsAffected = 0;

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


	BOOL CADOConnection::IsConnectionOpened()
	{
		if(m_pConn )
			return m_pConn->GetState() != adStateClosed;
		return FALSE;
	}

	void CADOConnection::CloseConnection()
	{
		if(IsConnectionOpened())
			m_pConn->Close();
	}





	/************************************************************************/
	/* CADORecordset
	/************************************************************************/
	CADORecordset::CADORecordset()
	{
		m_pRS = NULL;
		m_pCmd = NULL;
		m_pRS.CreateInstance(__uuidof(Recordset));
		m_pCmd.CreateInstance(__uuidof(Command));

		m_strQuery = _T("");
		m_strLastError = _T("");
		m_dwLastError = 0;
		m_pRecBinding = NULL;
		m_nEditStatus = CADORecordset::dbEditNone;
		m_nSearchDirection = CADORecordset::searchForward;
	}

	CADORecordset::CADORecordset(CADOConnection* pDB)
	{
		m_pRS = NULL;
		m_pCmd = NULL;
		m_pRS.CreateInstance(__uuidof(Recordset));
		m_pCmd.CreateInstance(__uuidof(Command));
		m_pConn = pDB->GetActiveConnection();

		m_strQuery = _T("");
		m_strLastError = _T("");
		m_dwLastError = 0;
		m_pRecBinding = NULL;
		m_nEditStatus = CADORecordset::dbEditNone;
		m_nSearchDirection = CADORecordset::searchForward;
	}

	CADORecordset::~CADORecordset()
	{
		Close();
		if(m_pRS)		m_pRS.Release();
		if(m_pCmd)		m_pCmd.Release();

		m_pRS = NULL;
		m_pCmd = NULL;
		m_pRecBinding = NULL;

		m_strQuery = _T("");
		m_strLastError = _T("");
		m_dwLastError = 0;
		m_nEditStatus = dbEditNone;
	}

	BOOL CADORecordset::Open(_ConnectionPtr pConn, LPCTSTR lpstrExec, int nOption)
	{	
		Close();

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

		ASSERT(!m_strQuery.IsEmpty());

		if(m_pConn == NULL)
			m_pConn = pConn;

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

		try
		{
			m_pRS->CursorType = adOpenStatic;
			m_pRS->CursorLocation = adUseClient;
			if(bIsSelect || nOption == openQuery || nOption == openUnknown)
			{
				m_pRS->Open((LPCSTR)m_strQuery, _variant_t((IDispatch*)pConn, TRUE), 
					adOpenStatic, adLockOptimistic, adCmdUnknown);
			}
			else if(nOption == openTable)
			{
				m_pRS->Open((LPCSTR)m_strQuery, _variant_t((IDispatch*)pConn, TRUE), 
					adOpenKeyset, adLockOptimistic, adCmdTable);
			}
			else if(nOption == openStoredProc)
			{
				m_pCmd->ActiveConnection = pConn;
				m_pCmd->CommandText = _bstr_t(m_strQuery);
				m_pCmd->CommandType = adCmdStoredProc;
				m_pConn->CursorLocation = adUseClient;

				m_pRS = m_pCmd->Execute(NULL, NULL, adCmdText);
			}
			else
			{
				TRACE( "Unknown parameter. %d", nOption);
				return FALSE;
			}
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}

		return m_pRS != NULL;
	}

	BOOL CADORecordset::Open(LPCTSTR lpstrExec, int nOption)
	{
		ASSERT(m_pConn != NULL);
		ASSERT(m_pConn->GetState() != adStateClosed);
		return Open(m_pConn, lpstrExec, nOption);
	}

	BOOL CADORecordset::OpenSchema(int nSchema, LPCTSTR SchemaID)
	{
		try
		{
			_variant_t vtSchemaID = vtMissing;

			if(strlen(SchemaID) != 0)
				vtSchemaID = SchemaID;

			m_pRS = m_pConn->OpenSchema((enum SchemaEnum)nSchema, vtMissing, vtSchemaID);
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADORecordset::Requery()
	{
		if(IsOpen())
		{
			try
			{
				m_pRS->Requery(adExecuteRecord);
			}
			catch(_com_error &e)
			{
				DumpComError(e);
				return FALSE;
			}
		}
		return TRUE;
	}


	BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, double& dbValue)
	{	
		double val = (double)NULL;
		_variant_t vtFld;

		try
		{
			vtFld = m_pRS->Fields->GetItem(lpFieldName)->Value;
			switch(vtFld.vt)
			{
			case VT_R4:
				val = vtFld.fltVal;
				break;

			case VT_R8:
				val = vtFld.dblVal;
				break;

			case VT_DECIMAL:
				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)
		{
			DumpComError(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_pRS->Fields->GetItem(vtIndex)->Value;
			switch(vtFld.vt)
			{
			case VT_R4:
				val = vtFld.fltVal;
				break;

			case VT_R8:
				val = vtFld.dblVal;
				break;

			case VT_DECIMAL:
				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)
		{
			DumpComError(e);
			return FALSE;
		}
	}


	BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, long& lValue)
	{
		long val = (long)NULL;
		_variant_t vtFld;

		try
		{
			vtFld = m_pRS->Fields->GetItem(lpFieldName)->Value;
			if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
				val = vtFld.lVal;
			lValue = val;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(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_pRS->Fields->GetItem(vtIndex)->Value;
			if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
				val = vtFld.lVal;
			lValue = val;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}


	BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, unsigned long& ulValue)
	{
		long val = (long)NULL;
		_variant_t vtFld;

		try
		{
			vtFld = m_pRS->Fields->GetItem(lpFieldName)->Value;
			if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
				val = vtFld.ulVal;
			ulValue = val;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(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_pRS->Fields->GetItem(vtIndex)->Value;
			if(vtFld.vt != VT_NULL && vtFld.vt != VT_EMPTY)
				val = vtFld.ulVal;
			ulValue = val;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, int& nValue)
	{
		int val = NULL;
		_variant_t vtFld;

		try
		{
			vtFld = m_pRS->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)
		{
			DumpComError(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_pRS->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)
		{
			DumpComError(e);
			return FALSE;
		}
	}

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

		try
		{
			vtFld = m_pRS->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:
				{
					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: