adopack.cpp

ＡＤＯ封装类

						lBytesCopied++;
					}
					else
						break;
				}
				lngOffSet += ChunkSize;
			}
			catch(_com_error &e)
			{
				DumpComError(e);
				return FALSE;
			}
		}

		lngOffSet = 0;
		return TRUE;
	}

	BOOL CADORecordset::AppendChunk(LPCTSTR lpFieldName, LPVOID lpData, UINT nBytes)
	{

		FieldPtr pField = m_pRS->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_pRS->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)
		{
			DumpComError(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_pRS->GetString(adClipString, numRows, varCols, varRows, varNull);

		return (LPCTSTR)varOutput;
	}

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

	BOOL CADORecordset::AddNew()
	{
		m_nEditStatus = dbEditNone;
		if(m_pRS->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)
		{
			DumpComError(e);
			return FALSE;
		}	
	}

	BOOL CADORecordset::Update()
	{
		BOOL bret = TRUE;

		if(m_nEditStatus != dbEditNone)
		{

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

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

	void CADORecordset::CancelUpdate()
	{
		m_pRS->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;

		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;

		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_pRS->Bookmark = m_varBookmark;
			return TRUE;
		}
		return FALSE;
	}

	BOOL CADORecordset::Delete()
	{
		if(m_pRS->Delete(adAffectCurrent) != S_OK)
			return FALSE;

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

	BOOL CADORecordset::FindFirst(LPCTSTR lpFind)
	{
		m_pRS->MoveFirst();
		return Find(lpFind);
	}

	BOOL CADORecordset::FindNext()
	{
		if(m_nSearchDirection == searchForward)
		{
			m_pRS->Find(_bstr_t(m_strFind), 1, adSearchForward, m_varBookFind);
			if(!IsEof())
			{
				m_varBookFind = m_pRS->Bookmark;
				return TRUE;
			}
		}
		else
		{
			m_pRS->Find(_bstr_t(m_strFind), 1, adSearchBackward, m_varBookFind);
			if(!IsBof())
			{
				m_varBookFind = m_pRS->Bookmark;
				return TRUE;
			}
		}
		return FALSE;
	}

	BOOL CADORecordset::PutFieldValue(LPCTSTR lpFieldName, _variant_t vtFld)
	{
		if(m_nEditStatus == dbEditNone)
			return FALSE;

		try
		{
			m_pRS->Fields->GetItem(lpFieldName)->Value = vtFld; 
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;	
		}
	}


	BOOL CADORecordset::PutFieldValue(_variant_t vtIndex, _variant_t vtFld)
	{
		if(m_nEditStatus == dbEditNone)
			return FALSE;

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

	BOOL CADORecordset::Clone(CADORecordset &pRs)
	{
		try
		{
			pRs.m_pRS = m_pRS->Clone(adLockUnspecified);
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADORecordset::SetFilter(LPCTSTR strFilter)
	{
		ASSERT(IsOpen());

		try
		{
			m_pRS->PutFilter(strFilter);
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADORecordset::SetSort(LPCTSTR strCriteria)
	{
		ASSERT(IsOpen());

		try
		{
			m_pRS->PutSort(strCriteria);
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

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

		ASSERT(IsOpen());

		try
		{
			hr = m_pRS->Save(lpstrXMLFile, adPersistXML);
			return hr == S_OK;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
		return TRUE;
	}

	BOOL CADORecordset::OpenXML(LPCTSTR lpstrXMLFile)
	{
		HRESULT hr = S_OK;

		if(IsOpen())
			Close();

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

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

		ASSERT(!pAdoCommand->GetText().IsEmpty());
		try
		{
			m_pConn->CursorLocation = adUseClient;
			m_pRS = pAdoCommand->GetCommand()->Execute(NULL, NULL, pAdoCommand->GetType());
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}