adopack.cpp

ＡＤＯ封装类

	}



	/************************************************************************/
	/* CADOCommand
	/************************************************************************/
	CADOCommand::CADOCommand(CADOConnection* pDB, CString strCommandText, int nCommandType)
	{
		m_nRecordsAffected = 0;
		m_strCommandText = strCommandText;
		m_nCommandType = nCommandType;

		m_pCommand = NULL;
		m_pCommand.CreateInstance(__uuidof(Command));
		m_pCommand->CommandText = m_strCommandText.AllocSysString();
		m_pCommand->CommandType = (CommandTypeEnum)m_nCommandType;
		m_pCommand->ActiveConnection = pDB->GetActiveConnection();	
	}
	CADOCommand::~CADOCommand()
	{
		m_pCommand.Release();
		m_pCommand = NULL;
		m_strCommandText = _T("");
	}

	BOOL CADOCommand::AddParameter(CADOParameter* pAdoParameter)
	{
		ASSERT(pAdoParameter->GetParameter() != NULL);

		try
		{
			m_pCommand->Parameters->Append(pAdoParameter->GetParameter());
			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, int nValue)
	{

		_variant_t vtValue;

		vtValue.vt = VT_I2;
		vtValue.iVal = nValue;

		return AddParameter(strName, nType, nDirection, lSize, vtValue);
	}

	BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, long lValue)
	{

		_variant_t vtValue;

		vtValue.vt = VT_I4;
		vtValue.lVal = lValue;

		return AddParameter(strName, nType, nDirection, lSize, vtValue);
	}

	BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, double dblValue, int nPrecision, int nScale)
	{

		_variant_t vtValue;

		vtValue.vt = VT_R8;
		vtValue.dblVal = dblValue;

		return AddParameter(strName, nType, nDirection, lSize, vtValue, nPrecision, nScale);
	}

	BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, CString strValue)
	{

		_variant_t vtValue;

		vtValue.vt = VT_BSTR;
		vtValue.bstrVal = strValue.AllocSysString();

		return AddParameter(strName, nType, nDirection, lSize, vtValue);
	}

	BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, COleDateTime time)
	{

		_variant_t vtValue;

		vtValue.vt = VT_DATE;
		vtValue.date = time;

		return AddParameter(strName, nType, nDirection, lSize, vtValue);
	}


	BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, _variant_t vtValue, int nPrecision, int nScale)
	{
		try
		{
			_ParameterPtr pParam = m_pCommand->CreateParameter(strName.AllocSysString(), (DataTypeEnum)nType, (ParameterDirectionEnum)nDirection, lSize, vtValue);
			pParam->PutPrecision(nPrecision);
			pParam->PutNumericScale(nScale);
			m_pCommand->Parameters->Append(pParam);

			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}


	void CADOCommand::SetText(CString strCommandText)
	{
		ASSERT(!strCommandText.IsEmpty());

		m_strCommandText = strCommandText;
		m_pCommand->CommandText = m_strCommandText.AllocSysString();
	}

	void CADOCommand::SetType(int nCommandType)
	{
		m_nCommandType = nCommandType;
		m_pCommand->CommandType = (CommandTypeEnum)m_nCommandType;
	}

	BOOL CADOCommand::Execute()
	{
		_variant_t vRecords;
		m_nRecordsAffected = 0;
		try
		{
			m_pCommand->Execute(&vRecords, NULL, adCmdStoredProc);
			m_nRecordsAffected = vRecords.iVal;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}





	/************************************************************************/
	/* CADOParameter
	/************************************************************************/
	CADOParameter::CADOParameter(int nType, long lSize, int nDirection, CString strName)
	{
		m_strName = strName;
		m_nType = nType;

		m_pParameter = NULL;
		m_pParameter.CreateInstance(__uuidof(Parameter));
		m_pParameter->Direction = (ParameterDirectionEnum)nDirection;
		m_pParameter->Name = m_strName.AllocSysString();
		m_pParameter->Type = (DataTypeEnum)nType;
		m_pParameter->Size = lSize;
	}
	CADOParameter::~CADOParameter()
	{
		m_pParameter.Release();
		m_pParameter = NULL;
		m_strName = _T("");
	}
	BOOL CADOParameter::SetValue(int nValue)
	{
		_variant_t vtVal;

		ASSERT(m_pParameter != NULL);

		vtVal.vt = VT_I2;
		vtVal.iVal = nValue;

		try
		{
			if(m_pParameter->Size == 0)
				m_pParameter->Size = sizeof(int);

			m_pParameter->Value = vtVal;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}


	BOOL CADOParameter::SetValue(long lValue)
	{
		_variant_t vtVal;

		ASSERT(m_pParameter != NULL);

		vtVal.vt = VT_I4;
		vtVal.lVal = lValue;

		try
		{
			if(m_pParameter->Size == 0)
				m_pParameter->Size = sizeof(long);

			m_pParameter->Value = vtVal;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::SetValue(double dblValue)
	{
		_variant_t vtVal;

		ASSERT(m_pParameter != NULL);

		vtVal.vt = VT_R8;
		vtVal.dblVal = dblValue;

		try
		{
			if(m_pParameter->Size == 0)
				m_pParameter->Size = sizeof(double);

			m_pParameter->Value = vtVal;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::SetValue(CString strValue)
	{
		_variant_t vtVal;

		ASSERT(m_pParameter != NULL);

		if(!strValue.IsEmpty())
			vtVal.vt = VT_BSTR;
		else
			vtVal.vt = VT_NULL;

		vtVal.bstrVal = strValue.AllocSysString();

		try
		{
			if(m_pParameter->Size == 0)
				m_pParameter->Size = sizeof(char) * strValue.GetLength();

			m_pParameter->Value = vtVal;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::SetValue(COleDateTime time)
	{
		_variant_t vtVal;

		ASSERT(m_pParameter != NULL);

		vtVal.vt = VT_DATE;
		vtVal.date = time;

		try
		{
			if(m_pParameter->Size == 0)
				m_pParameter->Size = sizeof(DATE);

			m_pParameter->Value = vtVal;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::SetValue(_variant_t vtValue)
	{

		ASSERT(m_pParameter != NULL);

		try
		{
			if(m_pParameter->Size == 0)
				m_pParameter->Size = sizeof(VARIANT);

			m_pParameter->Value = vtValue;
			return TRUE;
		}
		catch(_com_error &e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::GetValue(int& nValue)
	{
		_variant_t vtVal;
		int nVal = 0;

		try
		{
			vtVal = m_pParameter->Value;

			switch(vtVal.vt)
			{
			case VT_BOOL:
				nVal = vtVal.boolVal;
				break;
			case VT_I2:
			case VT_UI1:
				nVal = vtVal.iVal;
				break;
			case VT_INT:
				nVal = vtVal.intVal;
				break;
			case VT_NULL:
			case VT_EMPTY:
				nVal = 0;
				break;
			default:
				nVal = vtVal.iVal;
			}	
			nValue = nVal;
			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::GetValue(long& lValue)
	{
		_variant_t vtVal;
		long lVal = 0;

		try
		{
			vtVal = m_pParameter->Value;
			if(vtVal.vt != VT_NULL && vtVal.vt != VT_EMPTY)
				lVal = vtVal.lVal;
			lValue = lVal;
			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::GetValue(double& dbValue)
	{
		_variant_t vtVal;
		double dblVal;
		try
		{
			vtVal = m_pParameter->Value;
			switch(vtVal.vt)
			{
			case VT_R4:
				dblVal = vtVal.fltVal;
				break;
			case VT_R8:
				dblVal = vtVal.dblVal;
				break;
			case VT_DECIMAL:
				//Corrected by Jos?Carlos Mart韓ez Gal醤
				dblVal = vtVal.decVal.Lo32;
				dblVal *= (vtVal.decVal.sign == 128)? -1 : 1;
				dblVal /= pow(10, vtVal.decVal.scale); 
				break;
			case VT_UI1:
				dblVal = vtVal.iVal;
				break;
			case VT_I2:
			case VT_I4:
				dblVal = vtVal.lVal;
				break;
			case VT_INT:
				dblVal = vtVal.intVal;
				break;
			case VT_NULL:
			case VT_EMPTY:
				dblVal = 0;
				break;
			default:
				dblVal = 0;
			}
			dbValue = dblVal;
			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::GetValue(CString& strValue, CString strDateFormat)
	{
		_variant_t vtVal;
		CString strVal = _T("");

		try
		{
			vtVal = m_pParameter->Value;
			switch(vtVal.vt) 
			{
			case VT_R4:
				strVal = DblToStr(vtVal.fltVal);
				break;
			case VT_R8:
				strVal = DblToStr(vtVal.dblVal);
				break;
			case VT_BSTR:
				strVal = vtVal.bstrVal;
				break;
			case VT_I2:
			case VT_UI1:
				strVal = IntToStr(vtVal.iVal);
				break;
			case VT_INT:
				strVal = IntToStr(vtVal.intVal);
				break;
			case VT_I4:
				strVal = LongToStr(vtVal.lVal);
				break;
			case VT_DECIMAL:
				{
					double val = vtVal.decVal.Lo32;
					val *= (vtVal.decVal.sign == 128)? -1 : 1;
					val /= pow(10, vtVal.decVal.scale); 
					strVal = DblToStr(val);
				}
				break;
			case VT_DATE:
				{
					COleDateTime dt(vtVal);

					if(strDateFormat.IsEmpty())
						strDateFormat = _T("%Y-%m-%d %H:%M:%S");
					strVal = dt.Format(strDateFormat);
				}
				break;
			case VT_EMPTY:
			case VT_NULL:
				strVal.Empty();
				break;
			default:
				strVal.Empty();
				return FALSE;
			}
			strValue = strVal;
			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::GetValue(COleDateTime& time)
	{
		_variant_t vtVal;

		try
		{
			vtVal = m_pParameter->Value;
			switch(vtVal.vt) 
			{
			case VT_DATE:
				{
					COleDateTime dt(vtVal);
					time = dt;
				}
				break;
			case VT_EMPTY:
			case VT_NULL:
				time.SetStatus(COleDateTime::null);
				break;
			default:
				return FALSE;
			}
			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}

	BOOL CADOParameter::GetValue(_variant_t& vtValue)
	{
		try
		{
			vtValue = m_pParameter->Value;
			return TRUE;
		}
		catch(_com_error& e)
		{
			DumpComError(e);
			return FALSE;
		}
	}





	/************************************************************************/
	/* 全局函数
	/************************************************************************/
	CString IntToStr(int nVal)
	{
		CString strRet;
		strRet.Format("%d", nVal);
		return strRet;
	}

	CString LongToStr(long lVal)
	{
		CString strRet;
		strRet.Format("%ld", lVal);
		return strRet;
	}

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


	CString DblToStr(double dblVal, int ndigits)
	{
		CString strRet;
		char buff[50];
		_gcvt(dblVal, ndigits, buff);
		strRet = buff;
		return strRet;
	}

	CString DblToStr(float fltVal)
	{
		CString strRet = _T("");
		char buff[50];
		_gcvt(fltVal, 10, buff);
		strRet = buff;
		return strRet;
	}


	void DumpComError(_com_error &e)
	{
		char strComError[256];	
		sprintf(strComError,"错误编号: %08lx\n错误信息: %s\n错误源  : %s\n错误描述: %s",
			e.Error(),	e.ErrorMessage(),	(LPCSTR) e.Source(),	(LPCSTR) e.Description()); 
		::MessageBox(NULL,strComError,"错误",MB_ICONEXCLAMATION);	
	}


	/************************************************************************/
	/* CJetEngine
	/************************************************************************/
	BOOL CJetEngine::CCompactDatabase(CString strDatabaseSource, CString strDatabaseDestination)
	{
		try
		{
			::CoInitialize(NULL);
			IJetEnginePtr jet(__uuidof(JetEngine));		
			HRESULT hr = jet->CompactDatabase(_bstr_t(strDatabaseSource.GetBuffer(0)), _bstr_t(strDatabaseDestination.GetBuffer(0)));
			::CoUninitialize();
			return hr == S_OK;
		}
		catch(_com_error &e) 
		{
			UNUSED_ALWAYS(e);
			::CoUninitialize();
			return FALSE;
		} 
	}


}