guiadodb.cpp

这是一个串口监视程序

//-----------------------------------------------------------------------//
// This is a part of the GuiLib MFC Extention.							 //	
// Autor  :  Francisco Campos											 //
// (C) 2002 Francisco Campos <www.beyondata.com> All rights reserved     //
// This code is provided "as is", with absolutely no warranty expressed  //
// or implied. Any use is at your own risk.								 //		
// You must obtain the author's consent before you can include this code //
// in a software library.												 //
// If the source code in  this file is used in any application			 //
// then acknowledgement must be made to the author of this program		 //	
// [e-mail]													 //
//-----------------------------------------------------------------------//

#include "stdafx.h"
#include "guiadodb.h"

//---------------------------------------------------------------------------------------

CString GetError(_com_error &e)
{	
	CString MsgBug;
	_bstr_t Source(e.Source());
	_bstr_t Description(e.Description());
	MsgBug.Format( "Ups!!! \nSource = %s\nDescription= %s\n",(LPCSTR)Source, (LPCSTR)Description );
	#ifdef _DEBUG
		AfxMessageBox( MsgBug, MB_OK | MB_ICONERROR );
	#endif	
	return MsgBug;
}


CString GetTypeVar(_variant_t vt)
{
	switch(vt.vt)
	{
	case VT_EMPTY :
		return _T("VT_EMPTY");
		break;
	case   VT_NULL :
		return _T("VT_NULL");
		break;
	case VT_I2:
		return _T("int");
		break;
	case VT_I4 :
		return _T("long");
		break;
	case  VT_R4 :
		return _T("float");
		break;
	case VT_R8 :
		return _T("double");
		break;
	case VT_CY :
		return _T("currency");
		break;
	case VT_DATE:
		return _T("date");
		break;
	case  VT_BSTR :
		return _T("string");
		break;
	case VT_DISPATCH :
		return _T("dispatch");
		break;
	case  VT_ERROR :
		return _T("error");
		break;
	case VT_BOOL :
		return _T("bool");
		break;
	case VT_VARIANT :
		return _T("variant");
		break;
	case VT_UNKNOWN :
		return _T("unknown");
		break;
	case   VT_DECIMAL :
		return _T("decimal");
		break;
	default:
		return _T("");
	}
}

CGuiConnection::CGuiConnection(void)
{
	::CoInitialize(NULL);
	m_pConn.CreateInstance(__uuidof(Connection));
	
}
CGuiConnection::~CGuiConnection(void)
{
	if (IsConnect())
		Close();
	m_pConn.Release();
	m_pConn = NULL;
	
}

BOOL CGuiConnection::Open(LPCTSTR ConnectionString,LPCTSTR UID,LPCTSTR PWD,long Options)
{
 HRESULT re;
 try
	{	
		re = m_pConn->Open(_bstr_t(ConnectionString), _bstr_t(UID), _bstr_t(PWD), NULL);
		return re == S_OK;
	}
	catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
 
}

BOOL CGuiConnection::IsConnect()
{
	return (BOOL) m_pConn->GetState() != adStateClosed;
}



CGuiRecordSet* CGuiConnection::Execute(LPCTSTR CommandText,long Options)
{
	CGuiRecordSet* m_rs= new CGuiRecordSet();
	try{
		m_rs->Open(m_pConn,CommandText,adOpenUnspecified,adLockUnspecified, Options);
	}catch(_com_error &e)
	{
		GetError(e);
		return NULL;
	}
	return m_rs;
}

long CGuiConnection::BeginTrans()
{
	return m_pConn->BeginTrans();
}

void CGuiConnection::RollbackTrans()
{
	m_pConn->RollbackTrans();
}

void CGuiConnection::CommitTrans()
{
	m_pConn->CommitTrans();
}

void CGuiConnection::Cancel()
{
	m_pConn->Cancel();
}

void CGuiConnection::Close()
{
	m_pConn->Close();
}

void CGuiConnection::SetConnectionTimeout(long ConnectionTimeout)
{
	m_pConn->ConnectionTimeout=ConnectionTimeout;
}

void CGuiConnection::SetConectionString( LPCTSTR ConnectionString)
{
	m_pConn->ConnectionString=ConnectionString;
}

long CGuiConnection::GetConnectionTimeout()
{
	return m_pConn->ConnectionTimeout;
}

LPCTSTR CGuiConnection::GetConectionString()
{
	return m_pConn->ConnectionString;
}


//***********************************************************************************************
CGuiRecordSet::CGuiRecordSet(void)
{
	::CoInitialize(NULL);
	m_rs.CreateInstance(__uuidof(Recordset));	
	m_Criteria=_T("");
}
CGuiRecordSet::~CGuiRecordSet(void)
{
	Close();
	if (m_rs) m_rs->Release();
	m_rs=NULL;
}
	
void CGuiRecordSet::Attach(_RecordsetPtr m_prs )
{
	m_rs=m_prs;
}

BOOL CGuiRecordSet::Open(_ConnectionPtr ActiveConnection,LPCTSTR Source, CursorTypeEnum CursorType,ADOCG::LockTypeEnum LockType, long Options)
{
	try
	{
		m_rs->Open(Source, _variant_t((IDispatch*)ActiveConnection, TRUE), 
							adOpenStatic, LockType, Options);
	}
	catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
	return TRUE;
}



BOOL CGuiRecordSet::FindFirst(LPCTSTR Criteria)
{
	MoveFirst();
   	return Find(Criteria,0,adSearchForward,"");
}

void CGuiRecordSet::Move(long NumRecords , _variant_t Start)
{
	m_rs->Move(NumRecords,vtMissing);
}

BOOL CGuiRecordSet::FindNext()
{
	return Find(m_Criteria,1,adSearchForward,vtPointer);
}


BOOL CGuiRecordSet::Find(LPCTSTR Criteria , long SkipRecords , 
						 SearchDirectionEnum SearchDirection,_variant_t Start)
{
	CString szCri=Criteria;

	if (!szCri.IsEmpty())
		m_Criteria=Criteria;
	else
		return FALSE;
	try{
		m_rs->Find(_bstr_t(Criteria),SkipRecords,SearchDirection,Start);
		if (SearchDirection ==adSearchForward)
		{
			if (!IsEof())
			{
				vtPointer= m_rs->Bookmark;
				return TRUE;
			}
		}else if (SearchDirection ==adSearchBackward)
		{
			if (!IsBof())
			{
				vtPointer= m_rs->Bookmark;
				return TRUE;
			}
		}else return FALSE;

	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
return FALSE;
}



BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,CString szCad)
{
	_variant_t vt;
	if(!szCad.IsEmpty())
	{
		vt.vt = VT_BSTR;
		vt.bstrVal = szCad.AllocSysString();
	}

	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,long lVal)
{
	_variant_t vt;
	vt.lVal=lVal;
	vt.vt=VT_I4;	
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned char usVal)
{
	_variant_t vt;
	vt.bVal=usVal;
	vt.vt=VT_UI1;	
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,short shVal)
{
	_variant_t vt;
	vt.iVal=shVal;
	vt.vt=VT_I2;	
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,float flVal)
{
	_variant_t vt;
	vt.fltVal=flVal;
	vt.vt=VT_R4;	
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,double dblVal)
{
	_variant_t vt;
	vt.dblVal=dblVal;
	vt.vt=VT_R8;	
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,BOOL blVal)
{
	_variant_t vt;
	vt.boolVal=blVal;
	vt.vt=VT_BOOL;	
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,COleDateTime dtVal)
{
	_variant_t vt;
	vt.date=dtVal;
	vt.vt=VT_DATE;	
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned long ulVal)
{
	_variant_t vt;
	vt.vt = VT_UI4;
	vt.ulVal = ulVal;
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetValue(LPCTSTR lpName, COleCurrency cuVal)
{
	_variant_t vt;
	vt.vt = VT_CY;
	vt.cyVal = cuVal.m_cur;
	if(cuVal.m_status == COleCurrency::invalid)
		return FALSE;
	return SetFieldValue(lpName, vt);
}

BOOL CGuiRecordSet::SetFieldValue(LPCTSTR lpName, _variant_t vtField)
{
	try
	{
		m_rs->Fields->GetItem(lpName)->Value = vtField; 
		return TRUE;
	}
	catch(_com_error &e)
	{
		GetError(e);
		return FALSE;	
	}
}


CString CGuiRecordSet::GetCollect(LPCTSTR lpField)
{
	try{
	_variant_t vt = m_rs->Fields->GetItem(lpField)->Value;
	 return (CString) vt.bstrVal;
	}
	catch(_com_error &e)
	{
		GetError(e);
		return _T("");
	}
 
}

BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,int& nValue)
{
	_variant_t vt;
	try
	{
		vt = m_rs->Fields->GetItem(lpField)->Value;
		if (vt.vt==VT_I2)
		{
			nValue=vt.intVal;
			return TRUE;
		}else if (vt.vt==VT_BOOL)
		{
			nValue=vt.boolVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}
BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,long& lVal)
{
	_variant_t vt;
	try
	{
		vt = m_rs->Fields->GetItem(lpField)->Value;
		if (vt.vt==VT_I4)
		{
			lVal=vt.lVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}

}
BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,double& dbVal)
{
	_variant_t vt;
	try
	{
		vt = m_rs->Fields->GetItem(lpField)->Value;
		if (vt.vt==VT_R8)
		{
			dbVal=vt.dblVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}
BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,CString& strValue)
{
	_variant_t vt;
	try
	{	
		vt = m_rs->Fields->GetItem(lpField)->Value;
		if (vt.vt==VT_BSTR)
		{
			strValue=vt.bstrVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}


BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleCurrency& cyVal)
{
	_variant_t vt;
	vt = m_rs->Fields->GetItem(lpField)->Value;
	
	try
	{
		if (vt.vt==VT_CY)
		{
			cyVal.m_cur=vt.cyVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}

}

BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleDateTime& dtVal)
{
	_variant_t vt;
	try
	{
		vt = m_rs->Fields->GetItem(lpField)->Value;
		if (vt.vt==VT_DATE)
		{
			dtVal=vt.date;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}
BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,float& flVal)
{
	_variant_t vt;
	try
	{
		vt = m_rs->Fields->GetItem(lpField)->Value;
		if (vt.vt==VT_R4)
		{
			flVal=vt.fltVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}

BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,_variant_t& vt)
{
	try
	{
		vt = m_rs->Fields->GetItem(lpField)->Value;
		return TRUE;
	}
	catch(_com_error& e)
	{
		GetError(e);
		return FALSE;
	}
}
	
BOOL CGuiRecordSet::GetCollect(int nIndex,int& nValue)
{
	_variant_t vt;
	_variant_t vtn;
	vtn.vt = VT_I2;
	try
	{
		vtn.iVal = nIndex;
		vt = m_rs->Fields->GetItem(vtn)->Value;
		if (vt.vt==VT_I2)
		{
			nValue=vt.intVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}

}

BOOL CGuiRecordSet::GetCollect(int nIndex,long& lVal)
{
	_variant_t vt;
	_variant_t vtn;
	vtn.vt = VT_I2;
	try
	{
		vtn.iVal = nIndex;
		vt = m_rs->Fields->GetItem(vtn)->Value;
		if (vt.vt==VT_I4)
		{
			lVal=vt.lVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}

}

BOOL CGuiRecordSet::GetCollect(int nIndex,double& dbVal)
{
	_variant_t vt;
	_variant_t vtn;
	vtn.vt = VT_I2;
	try
	{
		vtn.iVal = nIndex;
		vt = m_rs->Fields->GetItem(vtn)->Value;
		if (vt.vt==VT_R8)
		{
			dbVal=vt.dblVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}

BOOL CGuiRecordSet::GetCollect(int nIndex,CString& strValue)
{
	_variant_t vt;
	_variant_t vtn;
	vtn.vt = VT_I2;
	try
	{	
		vtn.iVal = nIndex;
		vt = m_rs->Fields->GetItem(vtn)->Value;
		if (vt.vt==VT_BSTR)
		{
			strValue=vt.bstrVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}

BOOL CGuiRecordSet::GetCollect(int nIndex,COleCurrency& cyVal)
{
	_variant_t vt;
	_variant_t vtn;
	vtn.vt = VT_CY;
	try
	{
		vtn.iVal =nIndex;
		vt	= m_rs->Fields->GetItem(vtn)->Value;
		if (vt.vt==VT_CY)
		{
			cyVal.m_cur=vt.cyVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}

}

BOOL CGuiRecordSet::GetCollect(int nIndex,COleDateTime& dtVal)
{
	_variant_t vt;
	_variant_t vtn;
	vtn.vt = VT_I2;
	try
	{
		vtn.iVal = nIndex;
		vt = m_rs->Fields->GetItem(vtn)->Value;
		if (vt.vt==VT_DATE)
		{
			dtVal=vt.date;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
		
}

BOOL CGuiRecordSet::GetFormatDate(LPCTSTR lpField,CString& m_szDate, CString Format)
{
	COleDateTime time;
	if (!GetCollect(lpField,time)) return FALSE;
	CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
	m_szDate =ct.Format(Format);
	return TRUE;
}

BOOL CGuiRecordSet::GetFormatDate(int nIndex,CString& m_szDate, CString Format)
{
	COleDateTime time;
	if (!GetCollect(nIndex,time)) return FALSE;
	CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
	m_szDate =ct.Format(Format);
	return TRUE;
}

BOOL CGuiRecordSet::GetCollect(int nIndex,float& flVal)
{
	_variant_t vt;
	_variant_t vtn;
	vtn.vt = VT_I2;
	try
	{
		vtn.iVal = nIndex;
		vt = m_rs->Fields->GetItem(vtn)->Value;
		if (vt.vt==VT_R4)
		{
			flVal=vt.fltVal;
			return TRUE;
		}else return FALSE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}

}



BOOL CGuiRecordSet::GetCollect(int nIndex,_variant_t& vt)
{

	_variant_t vtn;
	vtn.vt = VT_I2;
	try
	{
		vtn.iVal = nIndex;
		vt = m_rs->Fields->GetItem(vtn)->Value;
		return TRUE;
	}
	catch(_com_error& e)
	{
		GetError(e);
		return FALSE;
	}
}
	



BOOL CGuiRecordSet::SetFilter(LPCTSTR lpFilter)
{
	if (!IsOpen()) return FALSE;
	try
	{
		m_rs->PutFilter(lpFilter);
		return TRUE;
	}
	catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}

BOOL CGuiRecordSet::SetSort(LPCTSTR lpSort)
{
	if (!IsOpen()) return FALSE;
	try
	{
		m_rs->PutSort(lpSort);
		return TRUE;
	}
	catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
}
	

BOOL CGuiRecordSet::IsOpen()
{
	if(m_rs)
		return m_rs-> GetState() != adStateClosed;
	return FALSE;
}

void CGuiRecordSet::Close()
{
	if(IsOpen())
		m_rs->Close();	
	
}


void CGuiRecordSet::MoveFirst()
{
	m_rs->MoveFirst();
}

void CGuiRecordSet::MoveLast()
{
	m_rs->MoveLast();
}

void CGuiRecordSet::MoveNext()
{
	m_rs->MoveNext();
}

void CGuiRecordSet::MovePrevious()
{
	m_rs->MovePrevious();
}

void CGuiRecordSet::Cancel()
{
   m_rs->Cancel();	
}

void CGuiRecordSet::CancelUpdate()
{
  m_rs->CancelUpdate();	
}

BOOL CGuiRecordSet::Delete()
{
	try{
		if(m_rs->Delete(adAffectCurrent)== S_OK)
			if(m_rs->Update() ==S_OK)
			return TRUE;
	}catch(_com_error &e)
	{
		GetError(e);
		return FALSE;
	}
	return FALSE;
}


BOOL CGuiRecordSet::IsEof()
{
	return (BOOL)m_rs->EndOfFile;
}