adoset.cpp

我自己整理的一些VC源代码

// AdoSet.cpp: implementation of the CAdoSet class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SellMan.h"
#include "AdoSet.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
extern _ConnectionPtr connection;
extern CString strSource;
extern BOOL bConnected;

CAdoSet::CAdoSet()
{
	m_arField.SetSize( 0 );
	m_bOpened = FALSE;
	m_recordset.CreateInstance( _uuidof( Recordset ) );
	m_bAutoCommit = TRUE;
	m_pField = NULL;
	m_nField = 0;
}

CAdoSet::~CAdoSet()
{
	//if( m_bAutoCommit && IsOpen() ) m_recordset->Update();
	if( IsOpen() ) Close();
	m_recordset.Release();
}

void CAdoSet::AddField(CMyField *pField)
{
	m_arField.Add( pField );
}

int CAdoSet::GetColumnCount()
{
	return m_arField.GetSize();
}

BOOL CAdoSet::Open(LPCTSTR szSQL)
{
	BOOL bRet = FALSE;
	HRESULT hr;
	CString strSQL;
	_bstr_t bstr_sql;

	if( bConnected )
	{
		try
		{
			if( IsOpen() ) Close();
			if( szSQL )
				strSQL.Format( "select * from %s %s", m_strTableName, szSQL );
			else
				strSQL.Format( "select * from %s", m_strTableName );
			bstr_sql = strSQL;
			hr = m_recordset->Open( bstr_sql, _variant_t((IDispatch*)connection, true), 
				adOpenDynamic, /*adLockUnspecified*/adLockPessimistic, adCmdText );
			if( SUCCEEDED( hr ) )
			{
				m_bOpened = TRUE;
				bRet = TRUE;
				FetchOneRow();
				if( IsEOF() )
				{
					bRet = FALSE;
					Close();
				}
			}
		}
		catch( _com_error &e )
		{
			AfxMessageBox( e.ErrorMessage() );
		}
	}
	
	return bRet;
}

void CAdoSet::SetTableName(LPCTSTR szTableName)
{
	m_strTableName = szTableName;
}

BOOL CAdoSet::FetchOneRow()
{
	Fields * fields   = NULL;
	CMyField * pField = NULL;
	BSTR bstrColName;
	CString strTmp;
	HRESULT hr;

	m_recordset->get_Fields( &fields );
	if( fields )
	{
		long dfCount = fields->GetCount();
		long count = m_arField.GetSize();
		ASSERT( dfCount == count );
		for( long i = 0; i < count; i ++ )
		{
			hr = fields->Item[ i ]->get_Name( &bstrColName );
			strTmp = bstrColName;
			for( long j = 0; j < count; j ++ )
			{
				pField = (CMyField *)m_arField.GetAt( j );
				if( !pField->strColName.Compare( strTmp ) )
				{
					fields->Item[ i ]->get_Value( &pField->varValue );
					pField->strValue = VariantToString( pField->varValue );
					break;
				}
			}
			fields->Release();
		}
	}

	return TRUE;
}

BOOL CAdoSet::Close()
{
	if( IsOpen() ) m_recordset->Close();
	m_bOpened = FALSE;
	return TRUE;
}

BOOL CAdoSet::IsOpen()
{
	return m_bOpened;
}

BOOL CAdoSet::MoveNext()
{
	BOOL bRet = FALSE;
	if( SUCCEEDED( m_recordset->MoveNext() ) )
	{
		if ( m_pField )
			FetchOneRow( true );
		else
			FetchOneRow();
		bRet = TRUE;
	}
	return bRet;
}

BOOL CAdoSet::IsEOF()
{
	VARIANT_BOOL ValEof;
	/*ValEof = (short)*/m_recordset->get_adoEOF( &ValEof );
	if( ValEof ) return TRUE;
	return FALSE;
}

BOOL CAdoSet::AppendRecord()
{
	BOOL bRet = FALSE;
	Fields * fields   = NULL;
	Field  * field    = NULL;
	CMyField * pField = NULL;
	//DataTypeEnum data_type;
	VARIANT varCount;
//	BSTR bstrColName;
	CString strTmp,strSQL;
	HRESULT hr;
	_bstr_t bstr_sql;
	varCount.vt = VT_I4;

	if( bConnected )
	{
		strSQL.Format( "select * from %s", m_strTableName );
		bstr_sql = strSQL;
		if( !IsOpen() )
		{
			hr = m_recordset->Open( bstr_sql, _variant_t((IDispatch*)connection, true), 
				adOpenDynamic, /*adLockUnspecified*/adLockPessimistic, adCmdText );
			if( SUCCEEDED( hr ) ) m_bOpened = TRUE;
		}
		m_recordset->AddNew();
		m_recordset->get_Fields( &fields );
		if( fields )
		{
			long dfCount = fields->GetCount();
			long count = m_arField.GetSize();
			ASSERT( dfCount == count );
			//for( long i = 0; i < count; i ++ )
			{
				//hr = fields->Item[ i ]->get_Name( &bstrColName );
				//strTmp = bstrColName;
				for( long j = 0; j < count; j ++ )
				{
					pField = (CMyField *)m_arField.GetAt( j );
					bstr_sql = pField->strValue;
					m_recordset->Fields->GetItem( _bstr_t( pField->strColName ) )->Value = bstr_sql;
					/*if( !pField->strColName.Compare( strTmp ) )
					{
						varCount.lVal = i;
						fields->get_Item( varCount, &field );
						field->get_Type( &data_type );
						if( !ConstructVar( pField->strValue, data_type, &pField->varValue ) )
							return FALSE;
						hr = field->put_Value( pField->varValue );
						break;
					}*/
				}
			}
			fields->Release();
			if( m_bAutoCommit ) m_recordset->Update();
			//field->Release();
			bRet = TRUE;
		}
	}

	return bRet;
}

BOOL CAdoSet::DeleteRecord()
{
	BOOL bRet = FALSE;
	if( IsOpen() && !IsEOF() )
	{
		m_recordset->Delete( adAffectCurrent );
		bRet = TRUE;
	}

	return bRet;
}

BOOL CAdoSet::UpdateRecord()
{
	BOOL bRet = FALSE;
	Fields * fields   = NULL;
	Field  * field    = NULL;
	CMyField * pField = NULL;
	VARIANT varCount;
	CString strTmp,strSQL;
	_bstr_t bstr_sql;
	varCount.vt = VT_I4;

	if( bConnected && IsOpen() )
	{		
		m_recordset->get_Fields( &fields );
		if( fields )
		{
			long dfCount = fields->GetCount();
			long count = m_arField.GetSize();
			ASSERT( dfCount == count );
			//for( long i = 0; i < count; i ++ )
			{
				//hr = fields->Item[ i ]->get_Name( &bstrColName );
				//strTmp = bstrColName;
				for( long j = 0; j < count; j ++ )
				{
					pField = (CMyField *)m_arField.GetAt( j );
					bstr_sql = pField->strValue;
					m_recordset->Fields->GetItem( _bstr_t( pField->strColName ) )->Value = bstr_sql;
				}
			}
			fields->Release();
			if( m_bAutoCommit ) m_recordset->Update();
			bRet = TRUE;
		}
	}

	return bRet;
}

void CAdoSet::SetAutoCommit(BOOL bAutoCommit)
{
	m_bAutoCommit = bAutoCommit;
}

void CAdoSet::Commit()
{
	if( IsOpen() ) m_recordset->Update();
}

long CAdoSet::GetNextID(LPCTSTR lpszColName)
{
	_RecordsetPtr recordset;
	HRESULT hr;
	Fields * fields = NULL;
	VARIANT var_value;
	CString strTmp;

	hr = recordset.CreateInstance( _uuidof( Recordset ) );
	if( SUCCEEDED(hr) )
	{
		strTmp.Format( "select max( %s ) + 1 from %s", lpszColName, m_strTableName );
		_bstr_t query = strTmp;
		hr = recordset->Open( query, _variant_t((IDispatch*)connection, true), 
			adOpenDynamic, adLockUnspecified/*adLockOptimistic*/, adCmdText );
		if( SUCCEEDED(hr) )
		{
			recordset->get_Fields( &fields );
			fields->Item[ (long)0 ]->get_Value( &var_value );
			strTmp = VariantToString( var_value );
			if( strTmp.IsEmpty() ) strTmp = "1";
			fields->Release();
		}
	}

	return atol( strTmp );
}

BOOL CAdoSet::Query(LPCTSTR szSQL,CMyField* pField, int nField)
{
	BOOL bRet = FALSE;
	HRESULT hr;
	CString strSQL;
	_bstr_t bstr_sql;

	if( bConnected )
	{
		try
		{
			m_nField = nField;
			m_pField = pField;
			if( IsOpen() ) Close();
			strSQL.Format( "%s", szSQL );
			bstr_sql = strSQL;
			hr = m_recordset->Open( bstr_sql, _variant_t((IDispatch*)connection, true), 
				adOpenForwardOnly, adLockPessimistic, adCmdText );
			if( SUCCEEDED( hr ) )
			{
				m_bOpened = TRUE;
				bRet = TRUE;
				FetchOneRow( true );
				if( IsEOF() )
				{
					bRet = FALSE;
					Close();
				}
			}
		}
		catch( _com_error &e )
		{
			AfxMessageBox( e.ErrorMessage() );
		}
	}
	
	return bRet;
}

BOOL CAdoSet::FetchOneRow(BOOL bQuery)
{
	Fields * fields   = NULL;
	BOOL bRet = FALSE;

	m_recordset->get_Fields( &fields );
	if( fields )
	{
		long dfCount = fields->GetCount();
		ASSERT( dfCount == (long)m_nField );
		for( long i = 0; i < m_nField; i ++ )
		{
		
			fields->Item[ i ]->get_Value( &m_pField->varValue );
			m_pField[i].strValue = VariantToString( m_pField->varValue );
			
		}
		fields->Release();
	}

	
	return bRet;
}