adodb.cpp

电子监控的网络编程实例

		return FALSE;
 	lValue = val;
 	return true;
}


bool CADODataset::GetFieldValue(LPCTSTR lpFieldName, int& nValue)
{

	int val = NULL;
	_variant_t vtFld;
	
	vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
	switch(vtFld.vt)
	{
	case VT_I2:
		val = vtFld.iVal;
		break;
	case VT_UI1:
		val = vtFld.iVal;
		break;

	case VT_I4:

		val = vtFld.iVal;
		break;
	case VT_BOOL:
		val = vtFld.boolVal;
		break;
	case VT_NULL:
		val=0;
		break;
	case VT_EMPTY:
		val=0;
		break;
	case VT_BSTR:
		try
		{
		   val=atoi((char*)vtFld.bstrVal);
		   break;
		}
        catch( char* str )
		{
			WriteLog(str,2); 
#ifdef _DEBUG
		  AfxMessageBox(str);
#endif
		  return 0;
		};
	default:
		nValue = 0;
		return false;
	}	
	nValue = val;
	return true;
}

bool CADODataset::GetFieldValue(int nIndex, int& nValue)
{
	int val = (int)NULL;
	_variant_t vtFld;
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
	switch(vtFld.vt)
	{
	case VT_I2:
		val = vtFld.iVal;
		break;
	case VT_I4:
		val = vtFld.iVal;
		break;
	case VT_NULL:
        val = 0;
		break;
	case VT_BOOL:
		val = vtFld.boolVal;
		break;
	case VT_EMPTY:
		val = 0;
		break;
	case VT_BSTR:
		try
		{
		   val=atoi((char*)vtFld.bstrVal);
		   break;
		}
        catch( char* str )
		{
			WriteLog(str,2); 
#ifdef _DEBUG
		  AfxMessageBox(str);
#endif
		  return 0;
		};
	default:
		return false;
	}	
	nValue = val;
	return true;
}

bool CADODataset::GetFieldValue(LPCTSTR lpFieldName, CString& strValue)
{
	CString str = _T("");
	CString s;
	ULONGLONG aa=0;
	_variant_t vtFld;
//	m_pRecordset->Fields->GetItem
	
	vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
	switch(vtFld.vt) 
	{
	case VT_BSTR:
		str = vtFld.bstrVal;
		break;
	case VT_DATE:
		{
			COleDateTime dt(vtFld);

			str = dt.Format("%Y-%m-%d %H:%M:%S");
		}
		break;
	case VT_EMPTY:
          
	case VT_NULL:
		str="";
		break;
	case VT_I1:
		str.Format("%d",vtFld.intVal);
		break;
	case VT_I2:
		str.Format("%d",vtFld.iVal);
		break;
	case VT_I4:
		str.Format("%d",vtFld.intVal);
		break;
	case VT_UI1:
		str.Format("%d",vtFld.intVal);
		break;
	case VT_BOOL:
		if(vtFld.boolVal==-1)
		{str="TRUE";}
		else
		{str="FALSE";}
		break;
	case VT_I8:
		str.Format("%d",vtFld.lVal);
		break;
	case VT_DECIMAL:
		aa = vtFld.decVal.Lo64;
		
		str="";

		while (aa>0)
		{
			s.Format("%d",aa%10);
			aa = aa/10;
			str = s+str;
		}


	//	str.Format("%ld-%ld-%ld",vtFld.decVal.Mid32,vtFld.decVal.Lo32);
		break;
	default:
		strValue.Empty();
		return false;
	}
	strValue = str;
	return true;
}

bool CADODataset::GetFieldValue(int nIndex, CString& strValue)
{
	CString str = _T("");
	_variant_t vtFld;
	_variant_t vtIndex;

	CString s;
	ULONGLONG aa=0;

	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
	switch(vtFld.vt) 
	{
	case VT_BSTR:
		str = vtFld.bstrVal;
		break;
	case VT_DATE:
		{
			COleDateTime dt(vtFld);
			str = dt.Format("%Y-%m-%d %H:%M:%S");
		}
		break;
	case VT_EMPTY:
		str="";
		break;
	case VT_NULL:
		str="";
		break;
	case VT_I1:
		str.Format("%d",vtFld.intVal);
		break;
	case VT_I2:
		str.Format("%d",vtFld.iVal);
		break;
	case VT_I4:
		str.Format("%d",vtFld.intVal);
		break;
	case VT_BOOL:
		if(vtFld.boolVal==-1)
		{str="TRUE";}
		else
		{str="FALSE";}
		break;
	case VT_I8:
		str.Format("%d",vtFld.lVal);
		break;
	case VT_DECIMAL:
		aa = vtFld.decVal.Lo64;
		
		str="";
		
		while (aa>0)
		{
			s.Format("%d",aa%10);
			aa = aa/10;
			str = s+str;
		}
		
		
		//	str.Format("%ld-%ld-%ld",vtFld.decVal.Mid32,vtFld.decVal.Lo32);
		break;
	default:
		strValue.Empty();
		break;
	}
	strValue = str;
	return true;
}

bool CADODataset::GetFieldValue(LPCTSTR lpFieldName, COleDateTime* time)
{
	_variant_t vtFld;
	
	vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
	switch(vtFld.vt) 
	{
	case VT_DATE:
		{
			time->m_dt = vtFld.dblVal;
			time->m_status =COleDateTime::DateTimeStatus::valid;//有效 
		}
		break;
	case VT_EMPTY:		  
	case VT_NULL:
		break;
	default:
		return false;
	}
	return true;
}

bool CADODataset::GetFieldValue(int nIndex, COleDateTime* time)
{
	_variant_t vtFld;
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
	switch(vtFld.vt) 
	{
	case VT_DATE:
		{
		    time->m_dt = vtFld.dblVal;
			time->m_status =COleDateTime::DateTimeStatus::valid;//有效 		
		}
		break;
	case VT_EMPTY:
	case VT_NULL:
		break;
	default:
		return false;
	}
	return true;
}
bool CADODataset::GetFieldValue(LPCTSTR lpFieldName, bool& boolValue)
{
	_variant_t vtFld;
	
	vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
	switch(vtFld.vt)
	{
	case VT_BOOL:
		if(vtFld.boolVal==-1)
		  boolValue=true;
		else
          boolValue=false;
		break;
	default:
		return false;
	}
	return true;
}
bool CADODataset::GetFieldValue(int nIndex, bool& boolValue)
{
	_variant_t vtFld;
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;
	
	vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
	switch(vtFld.vt)
	{
	case VT_BOOL:
    	if(vtFld.boolVal==-1)
		  boolValue=true;
		else
          boolValue=false;
		break;
	default:
		return false;
	}
	return true;

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

bool CADODataset::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 CADODataset::IsFieldEmpty(LPCTSTR lpFieldName)
{
	_variant_t vtFld;
	
	vtFld = m_pRecordset->Fields->GetItem(lpFieldName)->Value;
	return vtFld.vt == VT_EMPTY || vtFld.vt == VT_NULL;
}

bool CADODataset::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;
}

DWORD CADODataset::GetRecordCount()
{
	DWORD nRows = 0;
	
	nRows = m_pRecordset->GetRecordCount();

	if(nRows == -1)
	{
		nRows = 0;
		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;
}

bool CADODataset::IsOpen()
{
	try{
		if( m_pRecordset)
			return m_pRecordset->GetState() != adStateClosed;
	}catch (...) {
	}
	return false;
}

void CADODataset::Close()
{
	try{
		if(IsOpen())
			m_pRecordset->Close();
	}catch (...) {
	}
}


/*
bool CADODataset::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 CADODataset::dump_com_error(_com_error &e)
{
	CString ErrorStr;
	
	
	_bstr_t bstrSource(e.Source());
	_bstr_t bstrDescription(e.Description());
	ErrorStr.Format( "CADORecordset Error\n\tCode = %08lx\n\tCode meaning = %s\n\tSource = %s\n\tDescription = %s\n",
		e.Error(), e.ErrorMessage(), (LPCSTR)bstrSource, (LPCSTR)bstrDescription );
	m_strLastError = _T("Query = " + GetQuery() + '\n' + ErrorStr);
	WriteLog(ErrorStr,2);
	#ifdef _DEBUG
		AfxMessageBox( ErrorStr, MB_OK | MB_ICONERROR );
	#endif	
}

bool CADODataset::GetFieldInfo(LPCTSTR lpFieldName, CADOFieldInfo* fldInfo)
{
	_variant_t vtFld;
	
	strcpy(fldInfo->m_strName, (LPCTSTR)m_pRecordset->Fields->GetItem(lpFieldName)->GetName());
	//fldInfo->m_lSize = m_pRecordset->Fields->GetItem(lpFieldName)->GetActualSize();
	fldInfo->m_lDefinedSize = m_pRecordset->Fields->GetItem(lpFieldName)->GetDefinedSize();
	fldInfo->m_nType = m_pRecordset->Fields->GetItem(lpFieldName)->GetType();
	//fldInfo->m_lAttributes = m_pRecordset->Fields->GetItem(lpFieldName)->GetAttributes();
	return true;
}

bool CADODataset::GetFieldInfo(int nIndex, CADOFieldInfo* fldInfo)
{
	_variant_t vtFld;
	_variant_t vtIndex;
	
	vtIndex.vt = VT_I2;
	vtIndex.iVal = nIndex;

	strcpy(fldInfo->m_strName, (LPCTSTR)m_pRecordset->Fields->GetItem(vtIndex)->GetName());
	//fldInfo->m_lSize = m_pRecordset->Fields->GetItem(vtIndex)->GetActualSize();
	fldInfo->m_lDefinedSize = m_pRecordset->Fields->GetItem(vtIndex)->GetDefinedSize();
	fldInfo->m_nType = m_pRecordset->Fields->GetItem(vtIndex)->GetType();
	//fldInfo->m_lAttributes = m_pRecordset->Fields->GetItem(vtIndex)->GetAttributes();
	return true;
}


bool CADODataset::GetChunk(LPCTSTR lpFieldName, CString& strValue)
{
	CString str = _T("");
	long lngSize, lngOffSet = 0;
	_variant_t varChunk;    
	int ChunkSize = 100;

	lngSize = m_pRecordset->Fields->GetItem(lpFieldName)->ActualSize;
	
	str.Empty();
	while(lngOffSet < lngSize)
	{
		varChunk = m_pRecordset->Fields->GetItem(lpFieldName)->GetChunk(ChunkSize);
		str += varChunk.bstrVal;
		lngOffSet += ChunkSize;
	}

	lngOffSet = 0;
	strValue = str;
	return TRUE;
}

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

	if(strlen(lpCols) != 0)
		varCols = _bstr_t(lpCols);

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

	return (LPCTSTR)varOutput;
}

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

CString CADODataset::LongToStr(long lVal)
{
	CString strRet;
	char buff[20];