adorecordset.cpp

封装的ADO访问所有数据库的代码

// AdoRecordset.cpp: implementation of the CAdoRecordset class.
//
//////////////////////////////////////////////////////////////////////

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
#define CONST_DATA_SOURCE "Provider=SQLOLEDB.1;Persist Security Info=False;User ID=%s;Password=%s;Initial Catalog=ZH201;Data Source=%s"

CString CAdoRecordset::m_strServerName=_T("local");
CString CAdoRecordset::m_strLoginID=_T("DFADMIN");
CString CAdoRecordset::m_strLoginPassword=_T("19757855");
_ConnectionPtr CAdoRecordset::m_pConnection=NULL;
BOOL CAdoRecordset::m_bGuest=TRUE;
CAdoRecordset::CAdoRecordset()
{
	m_pRs=NULL;
}

CAdoRecordset::CAdoRecordset(const _RecordsetPtr& pRs)
{
	m_pRs=NULL;
	m_pRs=pRs;
}

CAdoRecordset::CAdoRecordset(LPCTSTR lpszSql,enum CursorTypeEnum cursorType,enum LockTypeEnum lockType,long options)
{
	BOOL bRet=Open(lpszSql,cursorType,lockType,options);	
	ASSERT(bRet);	
}
CAdoRecordset::~CAdoRecordset()
{
	m_pRs=NULL;	
}

//在Open之后调用,记录集为空时返回FALSE
BOOL CAdoRecordset::Requery(LPCTSTR lpszFiter)
{
	if(m_pRs->State!=adStateOpen||lpszFiter==NULL)
		return FALSE;
	CString strFilter=lpszFiter;
	
	m_pRs->Filter=_bstr_t(strFilter);
	m_pRs->Requery(adOptionUnspecified|adCmdText);
	
	return (!m_pRs->ADOEOF&&!m_pRs->BOF);
}
BOOL CAdoRecordset::AddNew()
{
	try
	{
		m_pRs->AddNew();
		return TRUE;
	}
	catch(_com_error& e)
	{
		Rollback(0);
		TRACE(e.Description());
		return FALSE;
	}
}
BOOL CAdoRecordset::Update()
{
	try
	{
		m_pRs->Update();
		return TRUE;
	}
	catch(_com_error& e)
	{
		m_pRs->CancelUpdate();
		TRACE(e.Description());
		return FALSE;
	}
}

FieldsPtr CAdoRecordset::GetFields()
{
	return m_pRs->GetFields();
}

BOOL CAdoRecordset::CancelUpdate()
{
	try
	{
		m_pRs->CancelUpdate();
		return TRUE;
	}
	catch(_com_error& e)
	{
		TRACE(e.Description());
		return FALSE;
	}
}
BOOL CAdoRecordset::Close()
{
	try
	{
		m_pRs->Close();
		return TRUE;
	}
	catch(_com_error& e)
	{
		TRACE(e.Description());
		return FALSE;
	}
	
}
BOOL CAdoRecordset::Delete(enum AffectEnum AffectRecords)
{
	try
	{
		m_pRs->Delete(AffectRecords);
		return TRUE;
	}
	catch(_com_error& e)
	{
		Rollback(0);
		TRACE(e.Description());
		return FALSE;
	}	
}
BOOL CAdoRecordset::IsEof()
{
	return m_pRs->ADOEOF;
}
BOOL CAdoRecordset::IsBof()
{
	return m_pRs->BOF;
}
BOOL CAdoRecordset::MoveFirst()
{
	try
	{
		m_pRs->MoveFirst();
		return TRUE;
	}
	catch(_com_error& e)
	{
		TRACE(e.Description());
		return FALSE;
	}	
}
BOOL CAdoRecordset::MoveNext()
{
	try
	{
		m_pRs->MoveNext();
		return TRUE;
	}
	catch(_com_error& e)
	{
		TRACE(e.Description());
		return FALSE;
	}	
}
BOOL CAdoRecordset::MoveLast()
{
	try
	{
		m_pRs->MoveLast();
		return TRUE;
	}
	catch(_com_error& e)
	{
		TRACE(e.Description());
		return FALSE;
	}	
}
BOOL CAdoRecordset::MovePrev()
{
	try
	{
		m_pRs->MovePrevious();
		return TRUE;
	}
	catch(_com_error& e)
	{
		TRACE(e.Description());
		return FALSE;
	}	
}

CAdoRecordset CAdoRecordset::Clone(enum LockTypeEnum lockType)
{
	return CAdoRecordset(m_pRs->Clone(lockType));
}

void CAdoRecordset::operator =(const _RecordsetPtr& pRs)
{
	m_pRs=NULL;
	m_pRs=pRs;
}

LONG CAdoRecordset::GetState()
{
	return m_pRs->State;
}

void CAdoRecordset::Copy(CAdoRecordset& set)
{
	m_pRs=NULL;
	m_pRs=set.GetRecordset();
}
_RecordsetPtr& CAdoRecordset::GetRecordset()
{
	return m_pRs;
}

CString CAdoRecordset::GetDataSource()
{
	CString strSource;
		
	strSource.Format(CONST_DATA_SOURCE,m_strLoginID,m_strLoginPassword,m_strServerName);
	
	return strSource; 
}

_variant_t CAdoRecordset::GetCollect(const _variant_t& Index)
{
	return m_pRs->GetCollect(Index);
}

void CAdoRecordset::PutCollect(const _variant_t& Index,const _variant_t& pVar)
{
	m_pRs->PutCollect(Index,pVar);
}


void CAdoRecordset::SetServerName(const CString &strServerName)
{
	m_strServerName=strServerName;
}

BOOL CAdoRecordset::Open(LPCTSTR lpszSql,enum CursorTypeEnum cursorType,enum LockTypeEnum lockType,long options,BOOL bFalseNoRecord)
{
	try
	{
		if(m_pConnection==NULL)
		{
			if(!InitConnection(m_pConnection,GetDataSource()))
			{
				m_pConnection=NULL;
				return FALSE;
			}
		}
		
		if(m_pRs==NULL)
		{
			HRESULT hResult=m_pRs.CreateInstance(__uuidof(Recordset));
			if(!SUCCEEDED(hResult))
			{
				m_pRs=NULL;
				return FALSE;
			}
		}
		_bstr_t varSql=CString(lpszSql);
		if(m_pRs->State==adStateOpen)
		{	
			m_pRs->Close();
		}
		m_pRs->MaxRecords=2000;
		m_pRs->Open(varSql,_variant_t((IDispatch*)m_pConnection),cursorType,lockType, options);
		
		if(bFalseNoRecord&&m_pRs->GetRecordCount()==0)
		{
			return FALSE;
		}
		
	}
	catch(_com_error & e)
	{
		TRACE((LPCSTR)e.Description ());
		return FALSE;
	}
	
	return TRUE; 
}

BOOL CAdoRecordset::InitConnection(_ConnectionPtr &pConn, CString strConnString)
{
	if(pConn==NULL)
	{
		HRESULT hResult=pConn.CreateInstance(__uuidof(Connection));
		if(!SUCCEEDED(hResult))
		{
			pConn=NULL;
			return FALSE;
		}
	}
	
	if(pConn->State==adStateOpen)
		pConn->Close();
	try
	{
		pConn->CursorLocation=adUseClient;
		pConn->Mode=adModeReadWrite;
		pConn->ConnectionString=(LPCSTR)strConnString;
		pConn->Open("","","",	adConnectUnspecified);		
	}
	
	catch(_com_error & e)
	{
		TRACE((LPCSTR)e.Description ());
		
#ifdef _DEBUG
		ErrorPtr  pErr = NULL;
		if( (pConn->Errors->Count) > 0)
		{
			long nCount = pConn->Errors->Count;
			// Collection ranges from 0 to nCount -1.
			for(long i = 0; i < nCount; i++)
			{
				pErr = pConn->Errors->GetItem(i);
				
				TRACE((LPCSTR)pErr->Description);
				
			}
		}
#endif
		return FALSE;
	}
	
	return TRUE; 
}


LONG CAdoRecordset::BeginTrans()
{
	return m_pConnection->BeginTrans();
}

BOOL CAdoRecordset::CommitTrans(LONG nTrans)
{
	return m_pConnection->CommitTrans();
}

BOOL CAdoRecordset::Rollback(LONG nTrans)
{
	return m_pConnection->RollbackTrans();
}

void CAdoRecordset::UnInit()
{
	if(m_pConnection)
	{
		if(m_pConnection->State==adStateOpen)
			m_pConnection->Close();
		m_pConnection=NULL;
	}
}

BOOL CAdoRecordset::BatchUpdate(enum AffectEnum AffectRecords)
{
	return SUCCEEDED(m_pRs->UpdateBatch(AffectRecords));
}

_RecordsetPtr CAdoRecordset::ExcuteSql( _bstr_t strCommandText, VARIANT * RecordsAffected, long Options )
{
	if(m_pConnection==NULL)
	{
		if(!InitConnection(m_pConnection,GetDataSource()))
		{
			m_pConnection=NULL;
			return NULL;
		}
	}
	
	if(m_pRs!=NULL)
		m_pRs=NULL;
	
	long nTans;
	try
	{
		nTans=BeginTrans();
		m_pRs=m_pConnection->Execute(strCommandText,RecordsAffected,Options);
		CommitTrans(nTans);
	}
	catch(_com_error& e)
	{
		TRACE(e.Description());
		m_pRs=NULL;
		Rollback(nTans);
	}
	return (m_pRs);
}

long CAdoRecordset::GetRowCount()
{
	return m_pRs->GetRecordCount();
}