adorecordset.cpp

基于UG平台

		if(m_pRecordset->adoEOF != VARIANT_TRUE)
			m_pRecordset->MoveFirst();
		
		while(m_pRecordset->adoEOF != VARIANT_TRUE)
		{
			nRows++;
			m_pRecordset->MoveNext();
		}
		if(nRows > 0)
			m_pRecordset->MoveFirst();
	}
	
	return nRows;
}

CString CADORecordset::GetString(CString lpCols, CString lpRows, CString lpNull, long numRows)
{
	_bstr_t varOutput;
	_bstr_t varNull("");
	_bstr_t varCols("\t");
	_bstr_t varRows("\r");

	if(lpCols.GetLength() != 0)
		varCols = _bstr_t(lpCols);

	if(lpRows.GetLength() != 0)
		varRows = _bstr_t(lpRows);
	
	if(numRows == 0)
		numRows =(long)GetRecordCount();			
			
	varOutput = m_pRecordset->GetString(adClipString, numRows, varCols, varRows, varNull);

	return (LPCTSTR)varOutput;
}

BOOL CADORecordset::IsBof()
{
	return m_pRecordset->adoBOF == VARIANT_TRUE;
}

BOOL CADORecordset::IsEof()
{
	return m_pRecordset->adoEOF == VARIANT_TRUE;
}

BOOL CADORecordset::IsFieldEmpty(int nIndex)
{
	_variant_t vtFld;
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
		
	vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
	return vtFld.vt == VT_EMPTY || vtFld.vt == VT_NULL;
}

bool CADORecordset::IsFieldEmpty(CString lpFieldName)
{
	_variant_t vtFld;
	
	vtFld = m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value;
	return vtFld.vt == VT_EMPTY || vtFld.vt == VT_NULL;
}

bool CADORecordset::IsFieldNull(CString lpFieldName)
{
	_variant_t vtFld;
	
	vtFld = m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value;
	return vtFld.vt == VT_NULL;
}

bool CADORecordset::IsFieldNull(int nIndex)
{
	_variant_t vtFld;
	_variant_t vtIndex;

	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
	return vtFld.vt == VT_NULL;
}

bool CADORecordset::IsOpen()
{
	if(m_pRecordset)
		return m_pRecordset->GetState() != adStateClosed;
	return false;
}

void CADORecordset::MoveFirst()
{
	m_pRecordset->MoveFirst();
}

void CADORecordset::MoveLast()
{
	m_pRecordset->MoveLast();
}

void CADORecordset::MoveNext()
{
	m_pRecordset->MoveNext();
}

void CADORecordset::MovePrevious()
{
	m_pRecordset->MovePrevious();
}

int CADORecordset::Open(CString lpstrExec, int nOption)
{
	ASSERT(m_pConnection != NULL);
	return Open(m_pConnection, lpstrExec, nOption);
}

int CADORecordset::Open(_ConnectionPtr mpdb, CString lpstrExec, int nOption)
{
	Close();
	
	if(! lpstrExec.IsEmpty())
		m_strQuery = lpstrExec;

	ASSERT(!m_strQuery.IsEmpty());
	
	m_strQuery.TrimLeft();
	BOOL bIsSelect = m_strQuery.Mid(0, 7).CompareNoCase(_T("select ")) == 0;

	try
	{
		m_pRecordset->CursorLocation = adUseClient;
		if(bIsSelect || nOption == openQuery)
			m_pRecordset->Open(_variant_t(m_strQuery), _variant_t((IDispatch*)mpdb, true), 
							adOpenStatic, adLockOptimistic, adCmdUnknown);
		else if(nOption == openTable)
			m_pRecordset->Open((_variant_t)m_strQuery, _variant_t((IDispatch*)mpdb, true), 
							adOpenDynamic, adLockOptimistic, adCmdTable);
		else if(nOption == openStoredProc)
		{
			m_pCmd->ActiveConnection = mpdb;
			m_pCmd->CommandText = _bstr_t(m_strQuery);
			m_pCmd->CommandType = adCmdStoredProc;
			
			m_pRecordset = m_pCmd->Execute(NULL, NULL, adCmdText);
		}
		else
		{
			return false;
		}
	}
	catch(_com_error &e)
	{
		dump_com_error(e);
		return false;
	}

	return m_pRecordset != NULL;
}

BOOL CADORecordset::RecordBinding(CADORecordBinding &pAdoRecordBinding)
{
	IADORecordBinding *picRs = NULL;
	HRESULT hr;

	//Open the binding interface.
	if(FAILED(hr = m_pRecordset->QueryInterface(__uuidof(IADORecordBinding), (LPVOID*)&picRs )))
	{
		_com_issue_error(hr);
		return false;
	}
	
	//Bind the recordset to class
	if(FAILED( hr = picRs->BindToRecordset(&pAdoRecordBinding)))
	{
		_com_issue_error(hr);
		return false;
	}
	return true;
}

void CADORecordset::SetAbsolutePage(int nPage)
{
	m_pRecordset->PutAbsolutePage((enum PositionEnum)nPage);
}

void CADORecordset::SetAbsolutePosition(int nPosition)
{
	m_pRecordset->PutAbsolutePosition((enum PositionEnum)nPosition);
}

bool CADORecordset::SetBookmark()
{
	if(m_varBookmark.vt != VT_EMPTY)
	{
		m_pRecordset->Bookmark = m_varBookmark;
		return true;
	}
	return false;
}

bool CADORecordset::SetFieldValue(int nIndex, CString strValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_BSTR;
	vtFld.bstrVal = _bstr_t(strValue);

	_variant_t vtIndex;	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	m_pRecordset->Fields->GetItem(vtIndex)->Value = _bstr_t(vtFld);//_bstr_t(strValue);
	return true;

}

bool CADORecordset::SetFieldValue(CString lpFieldName, CString strValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_BSTR;
	vtFld.bstrVal = _bstr_t(strValue);
	
	m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value = _bstr_t(vtFld);//_bstr_t(strValue);
	return true;
	
}

bool CADORecordset::SetFieldValue(int nIndex, int nValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_I2;
	vtFld.iVal = nValue;
	
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	m_pRecordset->Fields->GetItem(vtIndex)->Value = vtFld;
	return true;
	
}

bool CADORecordset::SetFieldValue(CString lpFieldName, int nValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_I2;
	vtFld.iVal = nValue;
	
	m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value = vtFld;
	return true;
	
}

bool CADORecordset::SetFieldValue(int nIndex, long lValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_I4;
	vtFld.lVal = lValue;
	
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	m_pRecordset->Fields->GetItem(vtIndex)->Value = vtFld;
	return true;
	
}

bool CADORecordset::SetFieldValue(CString lpFieldName, long lValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_I4;
	vtFld.lVal = lValue;
	
	m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value = vtFld;
	return true;
	
}

bool CADORecordset::SetFieldValue(int nIndex, double dblValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_R8;
	vtFld.dblVal = dblValue;

	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	m_pRecordset->Fields->GetItem(vtIndex)->Value = vtFld;
	return true;
	
}

bool CADORecordset::SetFieldValue(CString lpFieldName, double dblValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_R8;
	vtFld.dblVal = dblValue;
		
	m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value = vtFld;
	return true;
	
}

bool CADORecordset::SetFieldValue(int nIndex, COleDateTime time)
{
	_variant_t vtFld;
	vtFld.vt = VT_DATE;
	vtFld.date = time;
	
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	m_pRecordset->Fields->GetItem(vtIndex)->Value = vtFld;
	return true;
	
}

bool CADORecordset::SetFieldValue(CString lpFieldName, COleDateTime time)
{
	_variant_t vtFld;
	vtFld.vt = VT_DATE;
	vtFld.date = time;
	
	m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value = vtFld;
	return true;
	
}

void CADORecordset::SetPageSize(int nSize)
{
	m_pRecordset->PutPageSize(nSize);
}

void CADORecordset::SetQuery(CString strQuery)
{
	m_strQuery = strQuery;
}

BOOL CADORecordset::Update()
{
	bool bret = true;

	if(m_nEditStatus != dbEditNone)
	{
		if(m_pRecordset->Update() != S_OK)
			bret = false;
	}

	m_nEditStatus = dbEditNone;
	return bret;
}

CString CADORecordset::IntToStr(int nVal)
{
	CString strRet;
	char buff[10];
	
	itoa(nVal, buff, 10);
	strRet = buff;
	return strRet;
}

CString CADORecordset::LongToStr(long lVal)
{
	CString strRet;
	char buff[20];
	
	ltoa(lVal, buff, 10);
	strRet = buff;
	return strRet;
}

CString CADORecordset::ULongToStr(unsigned long ulVal)
{
	CString strRet;
	char buff[20];
	
	ultoa(ulVal, buff, 10);
	strRet = buff;
	return strRet;
}

CString CADORecordset::DblToStr(double dblVal, int ndigits)
{
	CString strRet;
	char buff[50];

   _gcvt(dblVal, ndigits, buff);
	strRet = buff;
	return strRet;
}

CString CADORecordset::DblToStr(float fltVal)
{
	CString strRet = _T("");
	char buff[50];
	
   _gcvt(fltVal, 10, buff);
	strRet = buff;
	return strRet;
}
//-------------------------------------------------------------
// 功能：获取记录集中字段的个数
// 参数：无
// 编写：风缘
// 时间：2003-1-1
//-------------------------------------------------------------
long CADORecordset::GetFieldsCount()
{
	return this->m_pRecordset->Fields->Count;
}
//-------------------------------------------------------------
// 功能：获得指定字段的名称
// 参数：nIndex——字段序号
// 编写：风缘
// 时间：2003-1-1
//-------------------------------------------------------------
CString CADORecordset::GetFieldName(int nIndex)
{
	_variant_t vtIndex;
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	CString str;
	str.Format(m_pRecordset->Fields->GetItem(vtIndex)->GetName());
	return str;
}

_RecordsetPtr CADORecordset::GetActiveRecordset()
{
	return this->m_pRecordset;
}

bool CADORecordset::GetFieldValue(CString lpFieldName, CString &strValue, CString strDateFormat)
{
	CString str = _T("");
	_variant_t vtFld;

	try
	{
		vtFld = m_pRecordset->Fields->GetItem(_variant_t(lpFieldName))->Value;
		switch(vtFld.vt) 
		{
		case VT_R4:
			str.Format(_T("%.7f"), vtFld.fltVal);
			str.TrimRight(_T("0"));
			break;
		case VT_R8:
			str.Format(_T("%.12f"), vtFld.dblVal);
			str.TrimRight(_T("0"));
			break;
		case VT_BSTR:
			str = vtFld.bstrVal;
			break;
		case VT_I2:
		case VT_UI1:
			str.Format(_T("%d"), vtFld.iVal);
			str.TrimRight(_T("0"));
			break;
		case VT_INT:
			str.Format(_T("%d"), vtFld.iVal);
			str.TrimRight(_T("0"));
			break;
		case VT_I4:
			str = LongToStr(vtFld.lVal);
			str.TrimRight(_T("0"));
			break;
		case VT_UI4:
			str.Format(_T("%lu"), vtFld.ulVal);//str = ULongToStr(vtFld.ulVal);
			str.TrimRight(_T("0"));
			break;
		case VT_DECIMAL:
			{
			//Corrected by Jos