adopack.cpp

ＡＤＯ封装类

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

	BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, COleDateTime& time)
	{
		_variant_t vtFld;

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

	BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, bool& bValue)
	{
		_variant_t vtFld;

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

	BOOL CADORecordset::GetFieldValue(LPCTSTR lpFieldName, COleCurrency& cyValue)
	{
		_variant_t vtFld;

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

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

	BOOL CADORecordset::GetFieldValue(int nIndex, _variant_t& vtValue)
	{
		_variant_t vtIndex;

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

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

	BOOL CADORecordset::IsFieldNull(LPCTSTR lpFieldName)
	{
		_variant_t vtFld;

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

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

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

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

	BOOL CADORecordset::IsFieldEmpty(LPCTSTR lpFieldName)
	{
		_variant_t vtFld;

		try
		{
			vtFld = m_pRS->Fields->GetItem(lpFieldName)->Value;
			return vtFld.vt == VT_EMPTY || vtFld.vt == VT_NULL;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

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

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

		try
		{
			vtFld = m_pRS->Fields->GetItem(vtIndex)->Value;
			return vtFld.vt == VT_EMPTY || vtFld.vt == VT_NULL;
		}
		catch(_com_error &e)
		{
			DumpComError(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);
	}


	long CADORecordset::GetRecordCount()
	{
		long nRows = 0;
		nRows = m_pRS->GetRecordCount();

		if(nRows == -1)
		{
			nRows = 0;
			if(m_pRS->EndOfFile != VARIANT_TRUE)
				m_pRS->MoveFirst();

			while(m_pRS->EndOfFile != VARIANT_TRUE)
			{
				nRows++;
				m_pRS->MoveNext();
			}
			if(nRows > 0)
				m_pRS->MoveFirst();
		}

		return nRows;
	}

	BOOL CADORecordset::IsOpen()
	{
		if(m_pRS != NULL && IsConnectionOpen())
			return m_pRS->GetState() != adStateClosed;
		return FALSE;
	}

	void CADORecordset::Close()
	{
		if(IsOpen())
		{
			if (m_nEditStatus != dbEditNone)
				CancelUpdate();

			m_pRS->PutSort(_T(""));
			m_pRS->Close();	
		}
	}


	BOOL CADORecordset::RecordBinding(CADORecordBinding &pAdoRecordBinding)
	{
		HRESULT hr;
		m_pRecBinding = NULL;

		//Open the binding interface.
		if(FAILED(hr = m_pRS->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_pRS->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_pRS->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_pRS->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_pRS->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)
			{
				DumpComError(e);
				return FALSE;
			}
		}

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

	BOOL CADORecordset::GetChunk(LPCTSTR lpFieldName, LPVOID lpData)
	{
		FieldPtr pField = m_pRS->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_pRS->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;