dhadofield.cpp

ADO查看数据库工具的原码

// DHAdoField.cpp: implementation of the CDHAdoField class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "DHAdoField.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

void	BinaryToString( CString& cStr, const CLongBinary& bin, bool bExpand )
{
	int	nSize = min( (int)bin.m_dwDataLength, cStr.GetLength() );
	if( bExpand )
		nSize = bin.m_dwDataLength;

	if( nSize < 1 ) {
		cStr.Empty();
		return;
	}

	void*	p = ::GlobalLock( bin.m_hData );
	if( p == NULL )
		::AfxThrowMemoryException();
	
	char* pStr = cStr.GetBuffer( nSize );
	memcpy( pStr, p, nSize );
	cStr.ReleaseBuffer( nSize );
	::GlobalUnlock( bin.m_hData );
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDHAdoField::CDHAdoField()
{
	m_FieldPtr = NULL;
}

CDHAdoField::~CDHAdoField()
{
	if(m_binary.m_hData != NULL)
	{
		::GlobalFree(m_binary.m_hData);
		m_binary.m_hData = NULL;
	}
}

CDHAdoField::CDHAdoField(const FieldPtr ptr)
{
	m_FieldPtr = ptr;
}

CLongBinary* CDHAdoField::AsBinary()
{
	try
	{
		if(!IsBinary())
		{
			return NULL;
		}
		long lDataSize = GetBinaryLen();
		if(lDataSize > 0)
		{
			_variant_t	varBLOB;
			varBLOB = m_FieldPtr->GetChunk(lDataSize);
			if(varBLOB.vt == (VT_ARRAY | VT_UI1))
			{
				if(m_binary.m_hData != NULL)
				{
					::GlobalFree(m_binary.m_hData);
					m_binary.m_hData = NULL;
				}
				if(m_binary.m_hData = ::GlobalAlloc(GMEM_FIXED , lDataSize+1))				///重新分配必要的存储空间
				{	
					m_binary.m_dwDataLength = lDataSize;
					memset(m_binary.m_hData, 0, lDataSize+1);
					char *pBuf = NULL;
					SafeArrayAccessData(varBLOB.parray,(void **)&pBuf);
					memcpy(m_binary.m_hData,pBuf,lDataSize);				///复制数据到缓冲区m_pBMPBuffer
					SafeArrayUnaccessData (varBLOB.parray);			
				}
			}
		}
		else
		{
			return NULL;
		}
		return &m_binary;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return NULL;
	}
}

bool CDHAdoField::AsBool() const
{
	try
	{
		if(IsNull())
			return false;
		switch( GetDBVT() )
		{
		case	DBVT_BOOL:
				if(m_FieldPtr->GetValue().boolVal == 0)
					return false;
				else
					return	true;

		case	DBVT_UCHAR:
				return	(m_FieldPtr->GetValue().cVal == 'T' || m_FieldPtr->GetValue().cVal == '1');
		case	DBVT_SHORT:
					return	(m_FieldPtr->GetValue().intVal != 0);
		case	DBVT_LONG:
					return	(m_FieldPtr->GetValue().lVal != 0);
		case	DBVT_SINGLE:
					return	(m_FieldPtr->GetValue().fltVal != 0.0);
		case    DBVT_DOUBLE:
					return	(m_FieldPtr->GetValue().dblVal != 0.0);
		case	DBVT_DATE:
					ASSERT( FALSE );
					break;
		case DBVT_STRING:
					return	(((char*)(_bstr_t)m_FieldPtr->GetValue().bstrVal)[0] == 'T' || (m_FieldPtr->GetValue().bstrVal)[0] == '1');
		case DBVT_BINARY:
					ASSERT( FALSE );
					break;
		}
		ASSERT( FALSE );
		return	false;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return false;
	}
}

unsigned char CDHAdoField::AsChar() const
{
	try
	{
		if(IsNull())
			return ' ';
		switch( GetDBVT() ) 
		{
		case	DBVT_UCHAR:
				return	m_FieldPtr->GetValue().cVal;
		case	DBVT_BOOL:
					return	(m_FieldPtr->GetValue().bVal) ? 'T' : 'F';
		case	DBVT_SHORT:
					return	(unsigned char)m_FieldPtr->GetValue().intVal;
		case	DBVT_LONG:
					return	(unsigned char)m_FieldPtr->GetValue().lVal;
		case	DBVT_SINGLE:
					return	(unsigned char)m_FieldPtr->GetValue().fltVal;
		case    DBVT_DOUBLE:
					return	(unsigned char)m_FieldPtr->GetValue().dblVal;
		case	DBVT_DATE:
					//	Cannot convert date to unsigned char
					ASSERT( FALSE );
					break;
		case DBVT_STRING:
					return	(unsigned char)((m_FieldPtr->GetValue().bstrVal)[0]);
		case DBVT_BINARY:
					//	Cannot convert long binary to unsigned char
					ASSERT( FALSE );
					break;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	' ';
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return  ' ';
	}
}

COleDateTime CDHAdoField::AsDate() const
{
	COleDateTime	date;
	try
	{
		if( IsNull() ) 
		{
			date.SetStatus( COleDateTime::null );
			return	date;
		}

		switch( GetDBVT() ) 
		{
		case	DBVT_UCHAR:
				date.SetStatus( COleDateTime::invalid );
				return	date;
		case	DBVT_BOOL:
				date.SetStatus( COleDateTime::invalid );
				return	date;
		case	DBVT_SHORT:
				return	COleDateTime( (time_t)m_FieldPtr->GetValue().intVal );
		case	DBVT_LONG:
				return	COleDateTime( (time_t)m_FieldPtr->GetValue().lVal );
		case	DBVT_SINGLE:
				return	COleDateTime( (time_t)m_FieldPtr->GetValue().fltVal );
		case    DBVT_DOUBLE:
				return	COleDateTime( (time_t)m_FieldPtr->GetValue().dblVal );
		case	DBVT_DATE:
				date = COleDateTime(m_FieldPtr->GetValue().date);
				if(date.GetYear() ==0 && date.GetMonth()==0 && date.GetDay()==0)
					date.SetStatus( COleDateTime::null );
				if(date.GetHour()==99 && date.GetMinute()==99 && date.GetSecond()==99)
					date.SetStatus( COleDateTime::null );
				return	date;
		case DBVT_STRING:
				date.ParseDateTime( (char*)(_bstr_t)(m_FieldPtr->GetValue().bstrVal) );		
			return	date;
		case DBVT_BINARY:	
				ASSERT( FALSE );
				break;
		}
		//	Undefined data type
		ASSERT( FALSE );
		date.SetStatus( COleDateTime::invalid );
		return	date;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		date.SetStatus( COleDateTime::invalid );
		return	date;
	}
}

double CDHAdoField::AsDouble() const
{
	try
	{
		if( IsNull() )
			return	0.0;

		switch( GetDBVT() )
		{
		case	DBVT_UCHAR:
				return	(double)m_FieldPtr->GetValue().cVal;
		case	DBVT_BOOL:
					return	(m_FieldPtr->GetValue().bVal) ? 1.0 : 0.0;
		case	DBVT_SHORT:
					return	(double)m_FieldPtr->GetValue().intVal;
		case	DBVT_LONG:
					return	(double)m_FieldPtr->GetValue().lVal;
		case	DBVT_SINGLE:
					return	(double)m_FieldPtr->GetValue().fltVal;
		case    DBVT_DOUBLE:
					return	m_FieldPtr->GetValue().dblVal;
		case	DBVT_DATE:
					//	Cannot convert date to unsigned char
					ASSERT( FALSE );
					break;
		case DBVT_STRING:
					return	atof((char*)(_bstr_t)(m_FieldPtr->GetValue()));
		case DBVT_BINARY:
					//	Cannot convert long binary to unsigned char
					ASSERT( FALSE );
					break;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	0.0;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return  0.0;
	}
}

float CDHAdoField::AsFloat() const
{
	try
	{
		if( IsNull() )
			return	0.0;
		switch( GetDBVT() )
		{
		case	DBVT_UCHAR:
				return	(float)m_FieldPtr->GetValue().cVal;
		case	DBVT_BOOL:
					return	(m_FieldPtr->GetValue().bVal) ? 1.0f: 0.0f;
		case	DBVT_SHORT:
					return	(float)m_FieldPtr->GetValue().intVal;
		case	DBVT_LONG:
					return	(float)m_FieldPtr->GetValue().lVal;
		case	DBVT_SINGLE:
					return	m_FieldPtr->GetValue().fltVal;
		case    DBVT_DOUBLE:
					return	(float)m_FieldPtr->GetValue().dblVal;
		case	DBVT_DATE:
					//	Cannot convert date to unsigned char
					ASSERT( FALSE );
					break;
		case DBVT_STRING:
					return	(float)atof((char*)(_bstr_t)(m_FieldPtr->GetValue().bstrVal));
		case DBVT_BINARY:
					//	Cannot convert long binary to unsigned char
					ASSERT( FALSE );
					break;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	0.0;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return  0.0;
	}
}

int CDHAdoField::AsInt() const
{
	return AsLong();
}

long CDHAdoField::AsLong() const
{
	try
	{
		COleDateTime date;
		CTime tm;
		if( IsNull() )
			return	0;
		switch( GetDBVT() )
		{
		case	DBVT_UCHAR:
				return	(long)m_FieldPtr->GetValue().cVal;
		case	DBVT_BOOL:
					return	(m_FieldPtr->GetValue().bVal) ? 1 : 0;
		case	DBVT_SHORT:
					return	(long)m_FieldPtr->GetValue().intVal;
		case	DBVT_LONG:
					return	m_FieldPtr->GetValue().lVal;
		case	DBVT_SINGLE:
					return	(long)m_FieldPtr->GetValue().fltVal;
		case    DBVT_DOUBLE:
					return	(long)m_FieldPtr->GetValue().dblVal;
		case	DBVT_DATE:
					date = COleDateTime(m_FieldPtr->GetValue().date);
					if(date.GetYear() ==0 && date.GetMonth()==0 && date.GetDay()==0)
					return (long)0;
					if(date.GetHour()==99 && date.GetMinute()==99 && date.GetSecond()==99)
					return (long)0;
					tm=CTime(date.GetYear(), date.GetMonth(), date.GetDay(),
					date.GetHour(), date.GetMinute(), date.GetSecond());
					return tm.GetTime();
					break;
		case	DBVT_STRING:
					return	atol((char*)m_FieldPtr->GetValue().pbstrVal);
		case	DBVT_BINARY:
					//	Cannot convert long binary to unsigned char
					ASSERT( FALSE );
					break;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	0;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return  0;
	}
}

short CDHAdoField::AsShort() const
{
	try
	{
		if( IsNull() )
			return	0;
		switch( GetDBVT() ) 
		{
		case	DBVT_UCHAR:
				return	(short)m_FieldPtr->GetValue().cVal;
		case	DBVT_BOOL:
					return	(m_FieldPtr->GetValue().bVal) ? 1 : 0;
		case	DBVT_SHORT:
					return	m_FieldPtr->GetValue().intVal;
		case	DBVT_LONG:
					return	(short)m_FieldPtr->GetValue().lVal;
		case	DBVT_SINGLE:
					return	(short)m_FieldPtr->GetValue().fltVal;
		case    DBVT_DOUBLE:
					return	(short)m_FieldPtr->GetValue().dblVal;
		case	DBVT_DATE:
					//	Cannot convert date to unsigned char
					ASSERT( FALSE );
					break;
		case DBVT_STRING:
					return	(short)atoi((char*)(_bstr_t)(m_FieldPtr->GetValue().bstrVal));
		case DBVT_BINARY:
					//	Cannot convert long binary to unsigned char
					ASSERT( FALSE );
					break;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	0;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return  0;
	}
}

CString CDHAdoField::AsString()
{
	CString	cValue="";
	try
	{
		if( IsNull() )
			return	cValue;
		switch(GetDBVT()) 
		{
		case	DBVT_UCHAR:
			return	CString( m_FieldPtr->GetValue().cVal );
		case	DBVT_BOOL:
				return	CString( m_FieldPtr->GetValue().bVal ? "T" : "F" );
		case	DBVT_SHORT:
				cValue.Format( "%hd", m_FieldPtr->GetValue().intVal );
				return	cValue;
		case	DBVT_LONG:
				cValue.Format( "%ld", m_FieldPtr->GetValue().lVal );
				return	cValue;
		case	DBVT_SINGLE:
				cValue.Format( "%.2f", m_FieldPtr->GetValue().fltVal );
				return	cValue;
		case    DBVT_DOUBLE:
				cValue.Format( "%.2f", m_FieldPtr->GetValue().dblVal );
				return	cValue;
		case	DBVT_DATE:
				cValue.Format( "%s", COleDateTime(m_FieldPtr->GetValue().date).Format("%Y/%m/%d %H:%M:%S"));
				return	cValue;
		case DBVT_STRING:	
				cValue = (char*)((_bstr_t)m_FieldPtr->GetValue());
				cValue.TrimRight();
				return	cValue;

		case DBVT_BINARY:
				::BinaryToString( cValue, *AsBinary(), true );
				return cValue;
		}
		//	Undefined data type
		ASSERT( FALSE );
		return	cValue;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return  cValue;
	}
}

long CDHAdoField::GetBinaryLen()
{
	try
	{
		if(IsBinary())
			return m_FieldPtr->GetActualSize();
		else
			return -1;
	}
	catch(_com_error& e)
	{
		TRACE1("%s\n", e.Description());
		return -1;
	}
}



BOOL CDHAdoField::DumpToFile(FILE *fp)
{
	try
	{
		DWORD dwSize;
		//写入字段类型
		//fwrite(&m_dwType, 1, sizeof(m_dwType), fp);	
		if(IsNull())
		{
			//写入字段长度
			dwSize=0;
			fwrite(&dwSize, 1, sizeof(dwSize), fp);
			return TRUE;
		}
		bool bval;
		unsigned char cval;
		short sval;
		long lval;
		float fval;
		double dval;
		CString strval;
		CLongBinary *pbinval;
		COleDateTime tmval;
		TIMESTAMP_STRUCT tmstamp;
		switch( GetDBVT() )
		{