adodb.cpp

电子监控的网络编程实例

	ltoa(lVal, buff, 10);
	strRet = buff;
	return strRet;
}
void WriteLog(CString info ,BYTE bType)
{
	if (g_ADODB_LogFileName=="NULL")
	{
		COleDateTime time=COleDateTime::GetCurrentTime();
		UINT ui = (bType==0)? MB_OK|MB_ICONINFORMATION:( (bType==1)? MB_OK|MB_ICONEXCLAMATION:MB_OK|MB_ICONSTOP);
		AfxMessageBox(info, ui);
	}
	else
	{
		CStdioFile* pTxtFile = new CStdioFile();
		try{
			CStdioFile* pTxtFile = new CStdioFile();
			if(!pTxtFile->Open(g_ADODB_LogFileName,CFile::modeReadWrite | CFile::typeText))
			{
				pTxtFile->Open(g_ADODB_LogFileName,CFile::modeWrite | CFile::modeCreate);
			}
			
			try
			{	
				pTxtFile->SeekToEnd();
				COleDateTime time=COleDateTime::GetCurrentTime();
				CString str;
				str.Format("%4d-%2d-%2d %2d:%2d:%2d",time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond());
				CString ss=(bType==0)? "状态":( (bType==1)? "警告":"错误");
				str=ss+":"+str;
				pTxtFile->WriteString(str+"------"+info+"\n");
				
				pTxtFile->Close();
			}catch (...) {
				pTxtFile->Close();
			}
			delete pTxtFile;
		}catch(...){
		}
	}
}

void CADODataset::Edit()
{
	m_nEditStatus = dbEdit;
}

bool CADODataset::AddNew()
{
	m_nEditStatus = dbEditNone;
	if(m_pRecordset->AddNew() != S_OK)
		return false;

	m_nEditStatus = dbEditNew;
		return true;
}

bool CADODataset::Update()
{
	bool bret = true;

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

	m_nEditStatus = dbEditNone;
	return bret;
}

void CADODataset::CancelUpdate()
{
	m_pRecordset->CancelUpdate();
	m_nEditStatus = dbEditNone;
}

bool CADODataset::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 CADODataset::SetFieldValue(LPCTSTR lpFieldName, CString strValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_BSTR;
	vtFld.bstrVal = _bstr_t(strValue);
//	vtFld.bstrVal = strValue.AllocSysString();
	m_pRecordset->Fields->GetItem(lpFieldName)->Value =_bstr_t(vtFld);//_bstr_t(strValue);
	return true;
	
}

bool CADODataset::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 CADODataset::SetFieldValue(LPCTSTR lpFieldName, int nValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_I2;
	vtFld.iVal = nValue;
	
	m_pRecordset->Fields->GetItem(lpFieldName)->Value = vtFld;
	return true;
	
}

bool CADODataset::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 CADODataset::SetFieldValue(LPCTSTR lpFieldName, long lValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_I4;
	vtFld.lVal = lValue;
	
	m_pRecordset->Fields->GetItem(lpFieldName)->Value = vtFld;
	return true;
	
}



bool CADODataset::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 CADODataset::SetFieldValue(LPCTSTR lpFieldName, double dblValue)
{
	_variant_t vtFld;
	vtFld.vt = VT_R8;
	vtFld.dblVal = dblValue;
		
	m_pRecordset->Fields->GetItem(lpFieldName)->Value = vtFld;
	return true;
	
}

bool CADODataset::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 CADODataset::SetFieldValue(LPCTSTR lpFieldName, COleDateTime time)
{
	//pRst->Fields->GetItem("fname")->AppendChunk(varChunk);
	
	_variant_t vtFld;
	vtFld.vt = VT_DATE;
	vtFld.date = time;
	
	m_pRecordset->Fields->GetItem(lpFieldName)->Value = vtFld;
	return true;
	
}

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

bool CADODataset::Delete()
{
	if(m_pRecordset->Delete(adAffectCurrent) != S_OK)
		return false;

	if(m_pRecordset->Update() != S_OK)
		return false;

	return true;
}

bool CADODataset::Find(LPCTSTR lpFind, int nSearchDirection)
{

	m_strFind = lpFind;
	m_nSearchDirection = nSearchDirection;

	ASSERT(!m_strFind.IsEmpty());

	if(m_nSearchDirection == searchForward)
	{
		m_pRecordset->Find(_bstr_t(m_strFind), 0, adSearchForward, "");
		if(!IsEof())
		{
			m_varBookFind = m_pRecordset->Bookmark;
			return true;
		}
	}
	else if(m_nSearchDirection == searchBackward)
	{
		m_pRecordset->Find(_bstr_t(m_strFind), 0, adSearchBackward, "");
		if(!IsBof())
		{
			m_varBookFind = m_pRecordset->Bookmark;
			return true;
		}
	}
	else
	{
		TRACE("Unknown parameter. %d", nSearchDirection);
		m_nSearchDirection = searchForward;
	}
	return false;
}

bool CADODataset::FindFirst(LPCTSTR lpFind)
{
	m_pRecordset->MoveFirst();
	return Find(lpFind);
}

bool CADODataset::FindNext()
{
	if(m_nSearchDirection == searchForward)
	{
		m_pRecordset->Find(_bstr_t(m_strFind), 1, adSearchForward, m_varBookFind);
		if(!IsEof())
		{
			m_varBookFind = m_pRecordset->Bookmark;
			return true;
		}
	}
	else
	{
		m_pRecordset->Find(_bstr_t(m_strFind), 1, adSearchBackward, m_varBookFind);
		if(!IsBof())
		{
			m_varBookFind = m_pRecordset->Bookmark;
			return true;
		}
	}
	return false;
}

bool CADODataset::SetFieldValue(LPCTSTR lpFieldName, BYTE* buf, long size)
{
	//pRst->Fields->GetItem("fname")->AppendChunk(varChunk);
	
	/*VARIANT vtFld;
	vtFld.vt = VT_ARRAY|VT_UI1;
	vtFld.parray = psa;
	
	m_pRecordset->Fields->GetItem(lpFieldName)->AppendChunk(vtFld);
	return true;*/

	VARIANT varChunk;
	SAFEARRAY *psa;
	SAFEARRAYBOUND rgsabound[1];
	
		if(size <= 0) return false;
		rgsabound[0].cElements =size;
		rgsabound[0].lLbound = 0;
		psa = SafeArrayCreate(VT_UI1,1,rgsabound);
		
		for(long index=0;index<size;index++)          
		{
			if(FAILED(SafeArrayPutElement(psa,&index,&buf[index])))
			{
		//		::AfxMessageBox(NULL,"ERROR","提示",MB_OK | MB_ICONWARNING);
				return false;
			}
		}
		
		varChunk.vt = VT_ARRAY|VT_UI1;
		varChunk.parray = psa;
		//m_pRecordset->Fields->GetItem("fname")-
		m_pRecordset->Fields->GetItem(lpFieldName)->AppendChunk(varChunk);
	//	m_pRecordset->Fields->GetItem("fname")
		::VariantClear(&varChunk);
		::SafeArrayDestroyData( psa);
	
		return true;
}


long CADODataset::GetChunkSize(LPCTSTR lpFieldName)
{
   return m_pRecordset->Fields->GetItem(lpFieldName)->ActualSize;
}
BOOL CADODataset::GetFieldValue(LPCTSTR lpFieldName, BYTE *buf, long size)
{
	_variant_t varChunk;
	varChunk = m_pRecordset->Fields->GetItem(lpFieldName)->GetChunk(size);
	
	for(long index=0;index<size;index++)         
	{           
		if(FAILED(::SafeArrayGetElement(varChunk.parray,&index,buf+index)))
		{
			//::AfxMessageBox(NULL,"ERROR","提示",MB_OK | MB_ICONWARNING);
			return false;
		}
	}
	::VariantClear(&varChunk);
	
	return TRUE;
}
bool CADODataset::SaveXml(LPCTSTR strFileName)
{
	_StreamPtr m_pStream;
	m_pStream.CreateInstance(__uuidof(Stream));


	variant_t varOptional(DISP_E_PARAMNOTFOUND,VT_ERROR);
	m_pStream->PutType(adTypeText);
	m_pStream->Open( varOptional,  
		adModeUnknown, adOpenStreamUnspecified, _bstr_t(), _bstr_t());
	m_pStream->LoadFromFile(strFileName);//读入文件

	//m_pStream->Open(_bstr_t("Select * from record"),adModeReadWrite, adOpenStreamUnspecified,"",""); 
	//m_pStream->LoadFromFile(strFileName);
	//m_pStream->WriteText(_T("aaaaaa"),stWriteLine);
m_pRecordset->Close();
m_pRecordset->Open("f.xml","Provider=MSPersist",adOpenForwardOnly,adLockReadOnly,adCmdFile);
//	m_pRecordset->Open(m_pStream.GetInterfacePtr(),"Provider=MsPersist"
//	, adOpenForwardOnly,adLockReadOnly,adCmdFile);


	//m_pRecordset->Save(strFileName,adPersistXML);

	//	m_pRecordset ->Save(_variant_t((IDispatch *)m_pStream,true),adPersistXML);
//	m_pStream->SaveToFile(L"C:\\XmlStreamSave.xml",adSaveCreateNotExist);
	
	return false;
}
// 写Blob字段
bool CADODataset::SetFieldBlob(LPCTSTR lpFieldName, VARIANT vtBlob)
{ 
	try
	{
		m_pRecordset->Fields->GetItem(lpFieldName)->AppendChunk(vtBlob);
	}
	catch (...) 
	{
		WriteLog("写BLOB字段出错",2);
#ifdef _DEBUG
			AfxMessageBox("写BLOB字段出错");
#endif
		return false;
	}
	return true;
}

BOOL CADOConnection::CreateAccessMDB(CString DbName, CString Password, CString User)
{
	try{
		if(GetFileAttributes(DbName)!=0xffffffff)
			DeleteFile(DbName);
	}catch(...){
		WriteLog("创建Mdb失败，已经存在["+DbName+"]该文件",2);
#ifdef _DEBUG
		AfxMessageBox("创建Mdb失败，已经存在["+DbName+"]该文件");
#endif
		return FALSE;
	}
	CString strConnect;
	strConnect="Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+DbName+";Jet OLEDB:Engine Type=5";
	if(Password!="")
	{
		strConnect=strConnect+"Jet OLEDB:Database Password="+Password+";";
	}


	ADOX::_CatalogPtr pCatalog = NULL;
//	strConnect="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\\NewMDB.mdb;Jet OLEDB:Engine Type=5";
	
	COleVariant Connect(strConnect); 
	try{
		TESTHR(pCatalog.CreateInstance(_T("ADOX.Catalog")));
		pCatalog->Create((LPCTSTR)strConnect);//创建数据库
	}catch(_com_error &e){
			CString str=(char*)e.Description();
			CString str2= str+e.ErrorMessage();
			str = str+"\n  "+e.ErrorMessage();
			WriteLog(str2,2);
#ifdef _DEBUG
			AfxMessageBox(str,MB_OK | MB_ICONERROR);
#endif
			return FALSE;
		}
		

	return TRUE;
}


char CADOConnection::CompactDatabase(CString DbName)
{
	char Flag=0;
	CString csSourceConnection,csDestConnection;
	csSourceConnection.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=%s",DbName);
	CString DbNameBak = DbName.Left(DbName.GetLength()-4)+CString("_b.mdb");
	try{
		DeleteFile(DbNameBak);
	}catch (...) {
	}
	csDestConnection.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=%s",DbNameBak);
	
	
	try{
		JRO::IJetEnginePtr jet(__uuidof(JRO::JetEngine));
		HRESULT bRst=jet->CompactDatabase((_bstr_t)csSourceConnection,(_bstr_t)csDestConnection);
		if (SUCCEEDED(bRst))
			Flag=1;
		else
		{
			WriteLog("压缩数据库["+DbName+"]失败",2);
			Flag=-1;
		}
		
		try{
			if(GetFileAttributes(DbName)!=0xffffffff)
				DeleteFile(DbName);
			MoveFile(DbNameBak,DbName);					
		}
		catch(...)
		{
			WriteLog("压缩数据库["+DbName+"]失败",2);
			Flag=-1;
		}


	}catch(_com_error &e){
		CString str=(char*)e.Description();
		CString str2= str+e.ErrorMessage();
		str = str+"\n  "+e.ErrorMessage();
		WriteLog(str2+"-压缩数据库["+DbName+"]失败",2);
#ifdef _DEBUG
		AfxMessageBox(str,MB_OK | MB_ICONERROR);
#endif
		Flag=-1;
	}catch(...){
		WriteLog("压缩数据库["+DbName+"]失败",2);
		Flag=-1;
	}
	return Flag;
}

char CADOConnection::RepairDatabase(CString dbName)
{
	/*
	char Flag=0;
	
	CString csSourceConnection;
	csSourceConnection.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=%s",dbName);
	
	try{
		JRO::IJetEnginePtr jet(__uuidof(JRO::JetEngine));
		BOOL bRst=jet->RepairDatabase(csSourceConnection.AllocSysString());
		if (bRst)
			Flag=1;
		else
		{
			WriteLog("修复数据库["+dbName+"]失败",2);
			Flag=-1;
		}	
		
	}catch(_com_error &e){
		CString str=(char*)e.Description();
		CString str2= str+e.ErrorMessage();
		str = str+"\n  "+e.ErrorMessage();
		WriteLog(str2+"-修复数据库["+dbName+"]失败",2);
#ifdef _DEBUG
		AfxMessageBox(str,MB_OK | MB_ICONERROR);
#endif
		Flag=-1;
	}catch(...){
		WriteLog("修复数据库["+dbName+"]失败",2);
		Flag=-1;
	}
	
	return Flag;*/
	return CompactDatabase(dbName);
}