dhadofield.cpp

ADO查看数据库工具的原码

				m_FieldPtr->PutValue((lVal != 0));
				return	*this;

		case	DBVT_UCHAR:
				m_FieldPtr->PutValue((unsigned char)lVal);
				return	*this;

		case	DBVT_SHORT:
				m_FieldPtr->PutValue((short)lVal);
				return	*this;

		case	DBVT_LONG:
				m_FieldPtr->PutValue((long)lVal);
				return	*this;

		case	DBVT_SINGLE:
				m_FieldPtr->PutValue((float)lVal);
				return	*this;

		case	DBVT_DOUBLE:
				m_FieldPtr->PutValue((double)lVal);
				return	*this;

		case	DBVT_DATE:
				if(lVal==0) SetNull();
				else
				{
					m_FieldPtr->PutValue(lVal);
				}
				return	*this;

		case	DBVT_STRING:

				str.Format( "%ld", lVal );
				m_FieldPtr->PutValue(_bstr_t(str));
				return	*this;

		case	DBVT_BINARY:
				//	CRecordset does not support writing to CLongBinary fields
				ASSERT( FALSE );
				return	*this;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	*this;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return *this;
	}
}
CDHAdoField& CDHAdoField::operator =( const DWORD lVal )
{
	try
	{
		CString str;
		switch( GetDBVT() ) {
		case	DBVT_NULL:
				//	Undefined data type
				ASSERT( FALSE );

		case	DBVT_BOOL:
				m_FieldPtr->PutValue((lVal != 0));
				return	*this;

		case	DBVT_UCHAR:
				m_FieldPtr->PutValue((unsigned char)lVal);
				return	*this;

		case	DBVT_SHORT:
				m_FieldPtr->PutValue((short)lVal);
				return	*this;

		case	DBVT_LONG:
				m_FieldPtr->PutValue((long)lVal);
				return	*this;

		case	DBVT_SINGLE:
				m_FieldPtr->PutValue((float)lVal);
				return	*this;

		case	DBVT_DOUBLE:
				m_FieldPtr->PutValue((double)lVal);
				return	*this;

		case	DBVT_DATE:
				if(lVal==0) SetNull();
				else
				{
					m_FieldPtr->PutValue((time_t)lVal);
				}
				return	*this;

		case	DBVT_STRING:

				str.Format( "%ld", lVal );
				m_FieldPtr->PutValue(_bstr_t(str));
				return	*this;

		case	DBVT_BINARY:
				//	CRecordset does not support writing to CLongBinary fields
				ASSERT( FALSE );
				return	*this;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	*this;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return *this;
	}
}
CDHAdoField& CDHAdoField::operator =( const float fltVal )
{
	try
	{
		CString str;
		switch( GetDBVT() ) 
		{
		case	DBVT_NULL:
				//	Undefined data type
				ASSERT( FALSE );

		case	DBVT_BOOL:
				m_FieldPtr->PutValue(fltVal != 0.0);
				return	*this;

		case	DBVT_UCHAR:
				m_FieldPtr->PutValue((unsigned char)fltVal);
				return	*this;

		case	DBVT_SHORT:
				m_FieldPtr->PutValue((short)fltVal);
				return	*this;

		case	DBVT_LONG:
				m_FieldPtr->PutValue((long)fltVal);
				return	*this;

		case	DBVT_SINGLE:
				m_FieldPtr->PutValue((float)fltVal);
				return	*this;

		case	DBVT_DOUBLE:
				m_FieldPtr->PutValue((double)fltVal);
				return	*this;

		case	DBVT_DATE:
				//	Cannot convert to datetime
				ASSERT( FALSE );
				return	*this;

		case	DBVT_STRING:
				str.Format( "%f", fltVal );
				m_FieldPtr->PutValue(_bstr_t(str));
				return	*this;

		case	DBVT_BINARY:
				//	CRecordset does not support writing to CLongBinary fields
				ASSERT( FALSE );
				return	*this;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	*this;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return *this;
	}
}
CDHAdoField& CDHAdoField::operator =( const double dblVal )
{
	try
	{
		CString str;
		switch( GetDBVT() ) 
		{
		case	DBVT_NULL:
				//	Undefined data type
				ASSERT( FALSE );

		case	DBVT_BOOL:
				m_FieldPtr->PutValue((dblVal != 0.0));
				return	*this;

		case	DBVT_UCHAR:
				m_FieldPtr->PutValue((unsigned char)dblVal);
				return	*this;

		case	DBVT_SHORT:
				m_FieldPtr->PutValue((short)dblVal);
				return	*this;

		case	DBVT_LONG:
				m_FieldPtr->PutValue((long)dblVal);
				return	*this;

		case	DBVT_SINGLE:
				m_FieldPtr->PutValue((float)dblVal);
				return	*this;

		case	DBVT_DOUBLE:
				m_FieldPtr->PutValue((double)dblVal);
				return	*this;

		case	DBVT_DATE:
				//	Cannot convert to datetime
				ASSERT( FALSE );
				return	*this;

		case	DBVT_STRING:
				str.Format( "%f", dblVal );
				m_FieldPtr->PutValue(_bstr_t(str));
				return	*this;

		case	DBVT_BINARY:
				//	CRecordset does not support writing to CLongBinary fields
				ASSERT( FALSE );
				return	*this;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	*this;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return *this;
	}
}
CDHAdoField& CDHAdoField::operator =( const CString& cVal )
{
	return	operator =( (LPCTSTR)cVal );
}
CDHAdoField& CDHAdoField::operator =( const LPCTSTR szVal )
{
	try
	{
		switch( GetDBVT() ) {
		case	DBVT_NULL:
				//	Undefined data type
				ASSERT( FALSE );

		case	DBVT_BOOL:
				m_FieldPtr->PutValue(szVal != NULL || atoi( szVal ) != 0 );
				return	*this;

		case	DBVT_UCHAR:
				m_FieldPtr->PutValue((unsigned char)szVal[0]);
				return	*this;

		case	DBVT_SHORT:
				m_FieldPtr->PutValue((short)atoi( szVal ));
				return	*this;

		case	DBVT_LONG:
				m_FieldPtr->PutValue((long)atol( szVal ));
				return	*this;

		case	DBVT_SINGLE:
				m_FieldPtr->PutValue((float)atof( szVal ));
				return	*this;

		case	DBVT_DOUBLE:
				m_FieldPtr->PutValue((double)atof( szVal ));
				return	*this;

		case	DBVT_DATE:
				if(strlen(szVal)==0) SetNull();
				else
				{
					COleDateTime	dt;
					dt.ParseDateTime( szVal );
					m_FieldPtr->PutValue(dt.m_dt);
				}
				return	*this;

		case	DBVT_STRING:
				m_FieldPtr->PutValue(_bstr_t(szVal));
				return	*this;

		case	DBVT_BINARY:
				//	CRecordset does not support writing to CLongBinary fields
				ASSERT( FALSE );  
				
				return	*this;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	*this;
	}
	catch(_com_error& e)
	{
		TRACE1("设置数据失败:%s\n", e.Description());
		return *this;
	}
}
CDHAdoField& CDHAdoField::operator =( const CLongBinary *szVal )
{
	if(!IsBinary())
	{ 
		ASSERT( FALSE );
	}
	SetBinData(szVal);
	return *this;
}
CDHAdoField& CDHAdoField::operator =( const COleDateTime& dtVal )
{
	try
	{
		CString str;
		switch( GetDBVT() ) {
		case	DBVT_NULL:
				//	Undefined data type
				ASSERT( FALSE );

		case	DBVT_BOOL:
		case	DBVT_UCHAR:
		case	DBVT_SHORT:
		case	DBVT_LONG:
		case	DBVT_SINGLE:
		case	DBVT_DOUBLE:
				//	Cannot convert to the current data type
				ASSERT( FALSE );
				return	*this;

		case	DBVT_DATE:
				if(dtVal.m_dt==0) SetNull();
				else
				{
					m_FieldPtr->PutValue(dtVal.m_dt);
				}
					return	*this;

		case	DBVT_STRING:
				str = dtVal.Format();
				m_FieldPtr->PutValue(_bstr_t(str));
				return	*this;

		case	DBVT_BINARY:
				//	CRecordset does not support writing to CLongBinary fields
				ASSERT( FALSE );
				return	*this;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	*this;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return *this;
	}
}
int CDHAdoField::GetDBVT() const
{
	try
	{
		switch( m_FieldPtr->GetType() )
		{
		case    adEmpty:
					return DBVT_NULL;
		case	adBoolean: 
					return DBVT_BOOL;
		case	adSmallInt:
					return	DBVT_SHORT;
		case    adInteger:
		case	adBigInt:
					return	DBVT_LONG;
		case	adSingle:
					return	DBVT_SINGLE;
		case    adNumeric:
		case	adDouble:
					return	DBVT_DOUBLE;
		case	adDate:
		case	adDBTime:
		case	adDBTimeStamp:
		case	adDBDate:
					return   DBVT_DATE;
		case	adChapter:
					return	DBVT_UCHAR;
		case	adChar:
		case	adWChar:
		case	adBSTR:
		case	adVarChar:
		case	adLongVarChar:
		case	adVarWChar:
		case	adLongVarWChar:
					return	DBVT_STRING;
		case	adBinary:
		case	adVarBinary:
		case	adLongVarBinary:
					return 	DBVT_BINARY;
		}
		ASSERT( FALSE );
		return	-1;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return -1;
	}
}

BOOL CDHAdoField::operator == (CDHAdoField& field )
{
	return (m_FieldPtr->GetValue() == field.GetValue());
}

const _variant_t CDHAdoField::GetValue()
{
	return	m_FieldPtr->GetValue();
}

BOOL CDHAdoField::SetBinData(const CLongBinary *pData)
{
	if(!IsBinary())
	{ 
		return FALSE;
	}
	COleVariant oleVariant(*pData);
	COleSafeArray safeAry;
	safeAry.Attach(oleVariant);
	try
	{
		HRESULT hr = m_FieldPtr->AppendChunk(safeAry);
		safeAry.Detach();
		return TRUE;
	}
	catch(_com_error& e)
	{
		safeAry.Detach();
		TRACE1("设置二进制数据失败:%s\n", e.Description());
		return FALSE;
	}
}

const enum DataTypeEnum CDHAdoField::GetType()
{
	return m_FieldPtr->GetType();
}

void CDHAdoField::SetNull()
{
	VARIANT v;
	V_VT(&v) = VT_NULL;
	m_FieldPtr->PutValue(v);
}

BOOL CDHAdoField::GetBinData(void *pData)
{
	try
	{
		BYTE *ptr;
		CLongBinary *pBin;
		pBin= AsBinary();
		if(pBin)
		{
			ptr=(BYTE *)GlobalLock(pBin->m_hData);
			memcpy(pData, ptr, pBin->m_dwDataLength);
			GlobalUnlock(pBin->m_hData);
		}
		return TRUE;
	}
	catch(_com_error& e)
	{
		TRACE1("[获取二进制字段数据失败]:%s",e.Description());
		return FALSE;
	}
}

BOOL CDHAdoField::SetBinData(void *pData, DWORD dwLen)
{
	if(!IsBinary())
	{ 
		return FALSE;
	}
	BYTE	*pBuf = (BYTE*)pData;
	VARIANT			varBIN;
	SAFEARRAY		*pSafeAry = NULL;
	SAFEARRAYBOUND	rgsabound[1];
	try
	{
		if(pBuf)
		{    
			rgsabound[0].lLbound = 0;
			rgsabound[0].cElements = dwLen;
			pSafeAry = SafeArrayCreate(VT_UI1, 1, rgsabound);
			for (long i = 0; i < (long)dwLen; i++)
			SafeArrayPutElement (pSafeAry, &i, pBuf++);
			varBIN.vt = VT_ARRAY | VT_UI1;
			varBIN.parray = pSafeAry;
			HRESULT hr = m_FieldPtr->AppendChunk(varBIN);
			SafeArrayDestroy(pSafeAry);
			return TRUE;
		}
		return FALSE;
	}
	catch(_com_error& e)
	{
		if(pSafeAry != NULL)
			SafeArrayDestroy(pSafeAry);
		TRACE1("设置二进制数据失败:%s\n", e.Description());
		return FALSE;
	}
}