📄 adomanager.cpp

📁 自动从数据库上移动数据,,,采用ORACAL数据库.
💻 CPP
字号:
// AdoManager.cpp : implementation file
// This class can be used to access database.
// Modify by nwj
// Date: 2006/11/15

#include "stdafx.h"
#include "AdoManager.h"
#include "Global.h"

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

/////////////////////////////////////////////////////////////////////////////
//global function and variant
void dump_com_error(_com_error &e)
{
	
//	_tprintf(_T("Oops - hit an error!\n"));
	TRACE(_T("\a\tCode = %08lx\n"), e.Error());
	TRACE(_T("\a\tCode meaning = %s\n"), e.ErrorMessage());
	_bstr_t bstrSource(e.Source());
	_bstr_t bstrDescription(e.Description());
	TRACE(_T("\a\tSource = %s\n"), (LPCTSTR) bstrSource);
	TRACE(_T("\a\tDescription = %s\n"), (LPCTSTR) bstrDescription);
	TRACE("\a\t%s\n",(LPCTSTR) bstrDescription);
//	AfxMessageBox((LPCTSTR) bstrDescription,MB_ICONERROR);

	char szError[512];
	memset(szError,0,sizeof(szError));
	global.error.Format("错误原因：(%s\n%s)",(LPCTSTR) bstrSource,(LPCTSTR) bstrDescription);
/*	sprintf(szError,"\a\tCode = %08lx\n",e.Error());
	PrintInfo(szError,PRINT_FAILED);

	sprintf(szError,"\a\tCode = %08lx\n",e.Error());
	PrintInfo(szError,PRINT_FAILED);
	sprintf(szError,"\a\tCode meaning = %s\n", e.ErrorMessage());
	PrintInfo(szError,PRINT_FAILED);

	_bstr_t bstrSource(e.Source());
	_bstr_t bstrDescription(e.Description());
*///	sprintf(szError,"\a\tSource = %s\n", (LPCTSTR) bstrSource);
//	PrintInfo(szError,PRINT_FAILED);

//	sprintf(szError,"\a\t%s\n",(LPCTSTR) bstrDescription);

//	PrintInfo(szError,PRINT_FAILED);
}

// Need two distinct "empty" VARIANTs for Command::Execute
static VARIANT* pvtEmpty = static_cast<VARIANT*> (&vtMissing);
static _variant_t vtMissing2(DISP_E_PARAMNOTFOUND, VT_ERROR);
static VARIANT* pvtEmpty2 = static_cast<VARIANT*> (&vtMissing2);

/////////////////////////////////////////////////////////////////////////////
//CRecordSet
CRecordSet::CRecordSet(ADODB::_ConnectionPtr gconnection,char *SqlStr)
{
	m_pRecordSet=NULL;
	Open(gconnection,SqlStr);
}

CRecordSet::~CRecordSet()
{
	Close();
	m_pRecordSet=NULL;
}
UINT CRecordSet::GetCount()
{
	return m_pRecordSet->GetRecordCount();

}


BOOL CRecordSet::Open(ADODB::_ConnectionPtr gconnection,char *filterstr)
{
	HRESULT hr;
	try
	{
		hr = m_pRecordSet.CreateInstance(__uuidof(ADODB::Recordset));
		//hr = m_pRecordSet.CreateInstance("ADODB.Recordset");
		if (FAILED(hr)) return hr;
		VARIANT v;
		V_VT(&v) = VT_DISPATCH;
		V_DISPATCH(&v) = (IDispatch*) gconnection;

		// Need the AddRef() as VariantClear() calls Release(), unless fAddRef
		// false indicates we're taking ownership
		//
		V_DISPATCH(&v)->AddRef();

		hr = m_pRecordSet->Open(filterstr, v,ADODB::adOpenStatic, ADODB::adLockOptimistic, 8);
	    V_DISPATCH(&v)->Release();

	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}

BOOL CRecordSet::Close()
{
	if(m_pRecordSet==NULL) return FALSE;
	HRESULT hr;
	try
	{
		hr = m_pRecordSet->Close();
	//	Release();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;	
}
long CRecordSet::GetCol()
{
	long col=0;
	ADODB::Fields* pFields;
	try{
		m_pRecordSet->get_Fields(&pFields);
		pFields->get_Count(&col);
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		pFields->Release();
		return -1;
	}
	pFields->Release();
	return col;

}

BOOL CRecordSet::MoveFirst()
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->MoveFirst();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;

}

BOOL CRecordSet::MoveLast()
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->MoveLast();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;

}

BOOL CRecordSet::MoveNext()
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->MoveNext();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}
BOOL CRecordSet::Move(long nNumber)
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->Move(nNumber);
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}

BOOL CRecordSet::IsEOF()
{
	HRESULT hr;
	try
	{
		hr = m_pRecordSet->EndOfFile;
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}

//从一行记录中取前FIELDNUM个值放到V[]数组中

BOOL CRecordSet::GetFields(VARIANT v[], int fieldnum)
{
	HRESULT hr;
/*	if(m_pRecordSet==NULL) return FALSE;
	ADODB::Fields* pFields;
	hr=m_pRecordSet->get_Fields(&pFields);
	if(FAILED(hr)) return hr;
	ADODB::Field* pField;
	
	VARIANT vitem;
	vitem.vt = VT_I1;
	for(int i=0;i<fieldnum;i++)
	{
		vitem.bVal = i;
		try{
			hr=pFields->get_Item(vitem,&pField);
			if(SUCCEEDED(hr))
				hr=pField->get_Value(&v[i]);
			if(FAILED(hr)) return hr;
		}catch (_com_error& e) 
		{
			dump_com_error(e);
			return -1;
		}
	}*/
	return hr;
}



BOOL CRecordSet::GetColValue(VARIANT *pv, int id)
{
	ADODB::Fields* pFields;
	ADODB::Field* pField;
	
	VARIANT vitem;
	vitem.vt = VT_I1;
	vitem.bVal = id;
	HRESULT hr;
	try{
		hr=m_pRecordSet->get_Fields(&pFields);
		hr=pFields->get_Item(vitem,&pField);
		hr=pField->get_Value(pv);
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		pField->Release();
		pFields->Release();
		return -1;
	}

	pField->Release();
	pFields->Release();
	return hr;
}
BOOL CRecordSet::GetColValue(VARIANT *pv, char* ColName)
{
	ADODB::Fields* pFields;
	ADODB::Field* pField;

	VARIANT vitem;
	vitem.vt   = VT_I1;
	vitem.bVal = 0;

	HRESULT hr;
	try{
		hr=m_pRecordSet->get_Fields(&pFields);
		while(!(hr=pFields->get_Item(vitem,&pField)))
		{
			_bstr_t bstr,tmpbstr;
			tmpbstr=ColName;
			bstr=pField->GetName();
			if(bstr==tmpbstr)
			{
				hr=pField->get_Value(pv);
				pField->Release();
				pFields->Release();
				return hr;
			}
			vitem.bVal ++ ;
			pField->Release();
		}
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		pField->Release();
		pFields->Release();
		return -1;
	}

	pFields->Release();
	return -1;
}
/////////////////////////////////////////////////////////////////////////////
//CAdoManager
CAdoManager::CAdoManager()
{
	gconnection=NULL;
	m_catalog=NULL;
}

CAdoManager::~CAdoManager()
{
	CloseDb();
	if(gconnection)
		gconnection.Release();
}

//////////////////////////////////////////////////////////////////
/*****************************************************************
*	NAME	:	InitConnection
*	Function:	Initialize database connection
*	Return	:	If connection is successful return 0 else not 0
*****************************************************************/

BOOL CAdoManager::OpenDb(char* ConnectionString)
{

	m_catalog.CreateInstance(__uuidof(Catalog));
	HRESULT hr = gconnection.CreateInstance(__uuidof(ADODB::Connection));
	try{
		if (SUCCEEDED(hr))
			hr = gconnection->Open(_bstr_t(ConnectionString), L"", L"",-1);
		    m_catalog->put_ActiveConnection(_variant_t((IDispatch *) gconnection));
		if (SUCCEEDED(hr))
			hr = m_pCommand.CreateInstance(__uuidof(ADODB::Command));
		if (SUCCEEDED(hr))
			hr = m_pCommand->putref_ActiveConnection(gconnection);
		
        gconnection->Properties->GetItem(_T("Data Source"))->Value;
	}catch(_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}

BOOL CAdoManager::OpenDbd(char* ConnectionString)
{
	HRESULT hr = gconnection.CreateInstance(__uuidof(ADODB::Connection));
	try{
		if (SUCCEEDED(hr))
			hr = gconnection->Open(_bstr_t(ConnectionString), L"", L"",-1);

		if (SUCCEEDED(hr))
			hr = m_pCommand.CreateInstance(__uuidof(ADODB::Command));
		if (SUCCEEDED(hr))
			hr = m_pCommand->putref_ActiveConnection(gconnection);

	}catch(_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;

}


void CAdoManager::CloseDb()
{
   if(gconnection==NULL || !IsOpen()) return;

	try{
		gconnection->Close();
        //m_catalog->cRelease();
		m_catalog=NULL;

	}catch (_com_error& e) 
	{
		dump_com_error(e);
	}
}

BOOL CAdoManager::IsOpen()
{
	if((gconnection!=NULL))
	{
		return gconnection->State == 1;
	}
	else
		return 0;
}

BOOL CAdoManager::Execute(char* query)
{
	HRESULT hr;
	try
	{
		hr = gconnection->Execute(_bstr_t(query), pvtEmpty, ADODB::adCmdText+ADODB::adExecuteNoRecords);

	}catch (_com_error& e) 
	{
//		PrintInfo(query,PRINT_FAILED);
		dump_com_error(e);
		if(e.Error()==0x80040e2f)
			return 2;
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}

BOOL CAdoManager::BeginTrans()
{
	HRESULT hr;
	try
	{
		hr = gconnection->BeginTrans() ;
	}catch (_com_error& e) 
	{
		
		dump_com_error(e);
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}

BOOL CAdoManager::CommitTrans()
{
	HRESULT hr;
	try
	{
		hr = gconnection->CommitTrans() ;
	}catch (_com_error& e) 
	{
		
		dump_com_error(e);
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}


BOOL CAdoManager::RollBackTrans()
{
	HRESULT hr;
	try
	{
		hr = gconnection->RollbackTrans() ;
	}catch (_com_error& e) 
	{
		
		dump_com_error(e);
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}

CRecordSet* CAdoManager::CreateRecordSet(char* query)
{
	CRecordSet* pRecordSet = new CRecordSet;
	if(!pRecordSet->Open(gconnection,query))
		return pRecordSet;
	else
	{
		delete pRecordSet;
		return NULL;
	}
}
//
void CAdoManager::DestroyRecordSet(CRecordSet* pRecordSet)
{
	delete pRecordSet;
	pRecordSet=NULL;
}


BOOL CRecordSet::GetColVar(DWORD pvalue, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	pvalue=(DWORD)v.ulVal;
	return rec;
}

BOOL CRecordSet::GetColVar(int& pvalue, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	pvalue=(int)v.intVal;
	return rec;
}
BOOL CRecordSet::GetColVar(CString *pStr, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	*pStr=v.bstrVal;
	::VariantClear(&v);
	return rec;
}
BOOL CRecordSet::GetColVar(char *pStr, char *colName)
{
//	VARIANT v;
	CString str="";
	BOOL rec=GetColVar(&str,colName);
	sprintf(pStr,"%s",str.GetBuffer(0));
	return rec;
}

BOOL CRecordSet::GetColVar(DATE *pdata, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	*pdata=v.date;
	return rec;
}

void CRecordSet::Delete(enum AffectEnum AffectRecords)
{
//	m_pRecordSet->Delete(AffectRecords);
}

BOOL CRecordSet::GetColVar(DATE& pDate, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	pDate=v.date;
	::VariantClear(&v);
	return rec;

}
BOOL CRecordSet::GetColVar(CString *pStr, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	if(v.vt==VT_NULL)
	{
		*pStr="";
		return false;
	}
	*pStr=v.bstrVal;
	::VariantClear(&v);
	return rec;

}
BOOL CRecordSet::GetColVar(char *pStr, int index)
{
//	VARIANT v;
	CString str="";
	BOOL rec=GetColVar(&str, index);
	sprintf(pStr,"%s",str.GetBuffer(0));
	return rec;

}

BOOL CRecordSet::GetColVar(DWORD& pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	pvalue=(DWORD)v.ulVal;
	::VariantClear(&v);
	return rec;
}
//万能的可否
BOOL CRecordSet::GetColVarAll(CString *pStr, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);


	if(v.vt==VT_NULL)
	{
		*pStr="";
		return false;
	}

	//一个一个试
	*pStr=v.bstrVal;
	if (pStr->GetLength()==0)
	{
       ;
	}   

	::VariantClear(&v);
	return rec;
}

BOOL CRecordSet::GetColVarSQL(int& pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	pvalue=v.intVal;
	::VariantClear(&v);
	return rec;
}

BOOL CRecordSet::GetColVar(int *pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	*pvalue=(int)v.dblVal;
	//	*pvalue=v.iVal;
	::VariantClear(&v);
	return rec;
}

BOOL CRecordSet::GetColVar(WORD *pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	*pvalue=(WORD)v.intVal;
	::VariantClear(&v);
	return rec;
}
/*BOOL CRecordSet::GetColVar(BYTE& pdata, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	pdata=v.bVal;
	return rec;
}*/
/*BOOL CRecordSet::GetColVar(float& pdata, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	pdata=v.fltVal;
	return rec;
}*/
void CRecordSet::Release()
{
	m_pRecordSet->Release();
}



BOOL CRecordSet::GetColValBYtype(void *pValue,short Index, short vt_type)
{

	VARIANT pv;
	ADODB::Fields* pFields;
	ADODB::Field* pField;
	
	VARIANT vitem;
	vitem.vt = VT_I1;
	vitem.bVal = Index;
	HRESULT hr;
	hr=m_pRecordSet->get_Fields(&pFields);
	hr=pFields->get_Item(vitem,&pField);
	hr=pField->get_Value(&pv);
	switch(pv.vt)
	{
		case VT_EMPTY:
			break;
		case VT_I2:
			{
				ASSERT((vt_type == VT_I2)  || (vt_type == VT_I4));
				if(vt_type == VT_I2)
				{
					*((short*)pValue) = pv.iVal;
				}
				else
				{
					*((long*)pValue) = pv.iVal;
				}
			}
			break;
		case VT_I4:
			{
				switch(vt_type)
				{
				case VT_I1:
					{
					*(BYTE*)pValue = (BYTE)pv.lVal;
						break;
					}
				default :
					*((long*)pValue) =pv.lVal;
				}
			}
			break;
		case VT_I1:
			{
				ASSERT(vt_type == VT_I4);
				*((long*)pValue) = pv.bVal;
			}
			break;
		case VT_BSTR:
			{
				ASSERT(vt_type == VT_BSTR);
				CString strTemp;
				strTemp.Format("%s",LPCTSTR(_bstr_t(pv)));
				strTemp.TrimRight();
				strcpy((char*)pValue, strTemp);
			}
			break;
		case VT_DATE:
			{
				ASSERT(vt_type == VT_DATE);
				COleDateTime date =pv.date;
				*((COleDateTime*) pValue) =pv.date;
				
			}
			break;
		case VT_R4:
			{
				ASSERT((vt_type == VT_R4) || (vt_type == VT_R8));
				if(vt_type == VT_R4)
					*((float*)pValue) = pv.fltVal;
				else
					*((double*)pValue) = pv.fltVal;
				break;
			}
		case VT_R8:
			{
				ASSERT(vt_type == VT_R8);
				*((double*) pValue) = pv.dblVal;
				break;
			}
		default:
			break;
	}

	pField->Release();
	pFields->Release();
	::VariantClear(&pv);
	return true;

}
💿 文件大小 255 K
👤 上传用户 jellylihui
📂 所属分类其他
🏷️ 相关标签

#ORACAL #数据库 #自动 #移动数据
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -