pos_ado.cpp

Visual C++高级编程及其项目应用开发(含源代码)

// Pos_ADO.cpp : Implementation of CPos_ADO
#include "stdafx.h"
#include "Pos_Server.h"
#include "Pos_ADO.h"
#include <string>

using namespace std;



// 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);
/////////////////////////////////////////////////////////////////////////////
// CPos_ADO

STDMETHODIMP CPos_ADO::Open(BSTR Computer, BSTR dbName, BSTR dbUser, BSTR dbPsw)
{
	HRESULT hr;
	hr = m_connection.CreateInstance("ADODB.Connection");///创建Connection对象
	
	if(SUCCEEDED(hr))
	{
		string strComputer = (_bstr_t)Computer;
		string strDBName = (_bstr_t)dbName;
		string strDBUser = (_bstr_t)dbUser;
		string strDBPsw = (_bstr_t)dbPsw;

		// Network Library=DBMSSOCN;
		string strConn1 = "Provider=SQLOLEDB.1;Persist Security Info=True;" ;
		string strConn2 = "User ID = ";
		string strConn3 = "Initial Catalog=";
		string strConn4 = "Data Source =";
		//string strConn7 = ",1433";
		string strConn6 = "Password=";
		string strConn5 = ";";
		string strConn;

		strConn = strConn1 + strConn2 + strDBUser +strConn5 + strConn3 + strDBName
			+ strConn5 + strConn4 +strComputer + strConn5 + strConn6 + strDBPsw + strConn5;
		
		//TCHAR *strTitle= _T("");
		//USES_CONVERSION;
		//strTitle = A2T(strConn.c_str());
		//MessageBox(NULL, strTitle, NULL, MB_OK);

		_bstr_t strBConn(strConn.c_str());
		
//		_bstr_t strBConn("Provider=SQLOLEDB.1;Password=begin_sa;"
//			"Persist Security Info=True;User ID=sa;"
//			"Initial Catalog=dbPos;Data Source=GUOXP");

		hr = m_connection->Open(strBConn,L"",L"", adConnectUnspecified);//adModeUnknown);///连接数据库

		if (SUCCEEDED(hr))
		{
			hr = m_command.CreateInstance("ADODB.Command");// or hr = m_command.CreateInstance(__uuidof(Command));
			if (SUCCEEDED(hr))
			{
				hr = m_command->putref_ActiveConnection(m_connection);
				if (SUCCEEDED(hr))
					hr = m_recordset.CreateInstance("ADODB.Recordset");
				else
					MessageBox(NULL,L"Can't ADODB.Recordset",L"Pos Server Error!",MB_OK);
			}
		}
		else
			MessageBox(NULL,L"can't Connection to DataBase...",L"Pos Server Error!",MB_OK);
		
	}
	else
		MessageBox(NULL,L"can't CreateInstance(ADODB.Connection)",L"Pos Server Error!",MB_OK);		

	return hr;
}

STDMETHODIMP CPos_ADO::OpenRecordset(VARIANT query)
{
	HRESULT hr;
	VARIANT v;
	V_VT(&v) = VT_DISPATCH;
	V_DISPATCH(&v) = (IDispatch*) m_connection;

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

	hr = m_recordset->put_CursorLocation(adUseClient);
	hr = m_recordset->Open(query, v, adOpenKeyset, adLockOptimistic, adCmdText);
	if (!SUCCEEDED(hr))
	{		
		MessageBox(NULL,L"can't OpenRecordset()",L"Pos Server Error!",MB_OK);
	}
	return hr;
}

STDMETHODIMP CPos_ADO::CloseRecordset()
{
	return m_recordset->Close();
}

STDMETHODIMP CPos_ADO::ExecuteConnection(BSTR query, VARIANT_BOOL bChangeRec)
{
	_Recordset* prec = 0;
	//_RecordsetPtr prec;
	
	HRESULT hr = m_connection->Execute(query, pvtEmpty, adCmdText, &prec);
	//prec = m_connection->Execute(query, pvtEmpty, adCmdText);

	if (SUCCEEDED(hr))
	//if(prec != NULL)
	{
		if (bChangeRec)
			m_recordset = prec;
		else
			prec->Release();
	}
	else		
	{		
		MessageBox(NULL,L"can't ExecuteConnection",L"Pos Server Error!",MB_OK);
		return E_FAIL;
	}
	return S_OK;
}

STDMETHODIMP CPos_ADO::ExecuteCommand(VARIANT_BOOL bStoredProcedure, VARIANT_BOOL bChangeRec)
{
	_Recordset* prec = 0;
	HRESULT hr;
	if (bStoredProcedure)
		hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdStoredProc, &prec);
	else
		hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
		if(SUCCEEDED(hr)) 
		{
			if (bChangeRec)
				m_recordset = prec;
			else
				prec->Release();
		}
		else
		{
			MessageBox(NULL,L"can't ExecuteCommand",L"Pos Server Error!",MB_OK);
			return E_FAIL;
		}
	return S_OK;
}

STDMETHODIMP CPos_ADO::get_CommandText(BSTR * pVal)
{
	HRESULT hr;
	hr = m_command->get_CommandText(pVal);
	if(!SUCCEEDED(hr))
	{
		MessageBox(NULL,L"can't get_CommandText",L"Pos Server Error!",MB_OK);
	}
	return hr;
}

STDMETHODIMP CPos_ADO::put_CommandText(BSTR newVal)
{
	return m_command->put_CommandText(newVal);	
}

STDMETHODIMP CPos_ADO::AppendParameter(enum DataTypeEnum type, VARIANT value, enum ParameterDirectionEnum where, long size)
{
	_ParameterPtr param;
	HRESULT hr = param.CreateInstance(__uuidof(Parameter));
	if (SUCCEEDED(hr))
		hr = param->put_Type(type);
	if (SUCCEEDED(hr))
		hr = param->put_Value(value);
	if (SUCCEEDED(hr))
		hr = param->put_Direction(where);
	if (SUCCEEDED(hr))
		hr = param->put_Size(size);

	Parameters* params = 0;
	if (SUCCEEDED(hr))
		hr = m_command->get_Parameters(&params);
	if (SUCCEEDED(hr))
		hr = params->Append(param);
	else	
		MessageBox(NULL,L"can't AppendParameter",L"Pos Server Error!",MB_OK);
	
	if (SUCCEEDED(hr))
	{
		params->Release();
		param->Release();
	}
	return hr;
}

STDMETHODIMP CPos_ADO::Update()
{
	return m_recordset->Update();
}

STDMETHODIMP CPos_ADO::Delete()
{
	return m_recordset->Delete(adAffectCurrent);
}

STDMETHODIMP CPos_ADO::get_Field(VARIANT idx, VARIANT * pVal)
{
	Fields* fields = 0;
	HRESULT hr = m_recordset->get_Fields(&fields);
	Field* field = 0;
	if (SUCCEEDED(hr))
		hr = fields->get_Item(idx, &field);
	if (SUCCEEDED(hr))
		hr = field->get_Value(pVal);

	if (SUCCEEDED(hr))
	{
		fields->Release();
		field->Release();
	}
	return hr;
}

STDMETHODIMP CPos_ADO::put_Field(VARIANT idx, VARIANT newVal)
{
	Fields* fields = 0;
	HRESULT hr = m_recordset->get_Fields(&fields);
	Field* field = 0;
	if (SUCCEEDED(hr))
		hr = fields->get_Item(idx, &field);
	if (SUCCEEDED(hr))
		hr = field->put_Value(newVal);

	if (SUCCEEDED(hr))
	{
		fields->Release();
		field->Release();
	}
	return hr;
}

STDMETHODIMP CPos_ADO::get_FieldCount(long * pVal)
{
	Fields* fields = 0;
	HRESULT hr = m_recordset->get_Fields(&fields);
	if (SUCCEEDED(hr))
		hr = fields->get_Count(pVal);
	if (SUCCEEDED(hr))
		fields->Release();
	return hr;
}

STDMETHODIMP CPos_ADO::Close()
{
	return m_connection->Close();
}

STDMETHODIMP CPos_ADO::First()
{
	return m_recordset->MoveFirst();
}

STDMETHODIMP CPos_ADO::Next()
{
	return m_recordset->MoveNext();
}

STDMETHODIMP CPos_ADO::Last()
{
	return m_recordset->MoveLast();
}

STDMETHODIMP CPos_ADO::Prev()
{
	return m_recordset->MovePrevious();
}

STDMETHODIMP CPos_ADO::get_EOF(VARIANT_BOOL * pVal)
{
	return m_recordset->get_adoEOF(pVal);
}

STDMETHODIMP CPos_ADO::get_BOF(VARIANT_BOOL * pVal)
{
	return m_recordset->get_BOF(pVal);
}

STDMETHODIMP CPos_ADO::ParamQuery(BSTR query, long idx1, BSTR idx2, BSTR idx3)
{
	TCHAR buf[10],bufer[10];	
	wprintf(buf,"%d",idx1);
	MessageBox(NULL,LPCTSTR(buf),L"Pos Server Error!",MB_OK);
	wprintf(bufer,"%d",10);
	MessageBox(NULL,LPCTSTR(bufer),L"Pos Server Error!",MB_OK);

	HRESULT hr = ChangeParameter(0, adInteger, (_variant_t) idx1, adParamInput, -1);
	if (SUCCEEDED(hr))
	{
		hr = ChangeParameter(1, adVarChar, (_variant_t) idx2, adParamInput, 25);
		if (SUCCEEDED(hr))
		{
			hr = ChangeParameter(2, adVarChar, (_variant_t) idx3, adParamInput, 80);
			if (SUCCEEDED(hr))
				hr = m_command->put_CommandText(query);
		}
	}
	else
	{		
		MessageBox(NULL,L"can't ParamQuery",L"Pos Server Error!",MB_OK);						
	}
	
	_Recordset* prec = 0;
	if (SUCCEEDED(hr))
		hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
	if (SUCCEEDED(hr)) 
	{
		prec->Release();
		return S_OK;
	}
	else
	{
		return E_FAIL;
	}
}

STDMETHODIMP CPos_ADO::CallStoredProc(long idx1, BSTR idx2, BSTR idx3)
{
	HRESULT hr = ChangeParameter(0, adInteger, (_variant_t) idx1, adParamInput, 4);
	if (SUCCEEDED(hr))
		hr = ChangeParameter(1, adVarChar, (_variant_t) idx2, adParamInput, 25);
	if (SUCCEEDED(hr))
		hr = ChangeParameter(2, adVarChar, (_variant_t) idx3, adParamInput, 80);
	if (SUCCEEDED(hr))
		hr = m_command->put_CommandText(L"{call MyProc (?, ?, ?)}");
	
	_Recordset* prec = 0;
	if (SUCCEEDED(hr))
		hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
	if (SUCCEEDED(hr)) 
	{
		prec->Release();
		return S_OK;
	}
	else
	{
		return E_FAIL;
	}
}

STDMETHODIMP CPos_ADO::put_StoredProc(BSTR newVal)
{
	if (newVal == NULL)
		newVal = ::SysAllocString(L"create procedure MyProc @i integer, @g varchar(25), @g varchar(80) into Guns (ID, Gun, [Gun Description]) values (@i, @g, @d) return");
	HRESULT hr = m_command->put_CommandText(newVal);

	_Recordset* prec = 0;
	if (SUCCEEDED(hr))
		hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
	if (SUCCEEDED(hr)) 
	{
		prec->Release();
		return S_OK;
	}
	else
	{
		return E_FAIL;
	}
}


STDMETHODIMP CPos_ADO::ChangeParameter(long idx, enum DataTypeEnum type, VARIANT value, enum ParameterDirectionEnum where, long size)
{
	Parameters* params = 0;
	HRESULT hr = m_command->get_Parameters(&params);

	_Parameter* param = 0;
	VARIANT v;
	V_VT(&v) = VT_I4;
	V_I4(&v) = idx;
	if (SUCCEEDED(hr))
		hr = params->get_Item(v, &param);

	if (SUCCEEDED(hr))
		hr = param->put_Type(type);
	if (SUCCEEDED(hr))
		hr = param->put_Value(value);
	if (SUCCEEDED(hr))
		hr = param->put_Direction(where);
	if (SUCCEEDED(hr))
		hr = param->put_Size(size);
	if (SUCCEEDED(hr))
	{
		params->Release();
		param->Release();
	}
	return hr;
}

STDMETHODIMP CPos_ADO::Requery()
{
	return S_OK;
}

STDMETHODIMP CPos_ADO::ADORelease()
{
	m_command = 0;
	m_recordset = 0;
	m_connection = 0;
	return S_OK;
}

STDMETHODIMP CPos_ADO::get_Empty(VARIANT_BOOL * bEmpty)
{
	HRESULT hr = m_recordset->get_adoEOF(bEmpty);
	if (SUCCEEDED(hr) && bEmpty)
		hr = m_recordset->get_BOF(bEmpty);
	return hr;
}

STDMETHODIMP CPos_ADO::get_RecordCount(long *pVal)
{
	// TODO: Add your implementation code here
	HRESULT hr = m_recordset->get_RecordCount(pVal);
	return hr;
}

STDMETHODIMP CPos_ADO::GetRs(VARIANT vSql, IDispatch **ppRecordset)
{
	// TODO: Add your implementation code here
	HRESULT		hr = S_OK;

	_RecordsetPtr	pRs;
	
	hr = pRs.CreateInstance(__uuidof(Recordset));
	if(!SUCCEEDED(hr))
	{
		MessageBox(NULL, L"Create Recordset Failed!", L"Pos Server Error!", MB_OK);
		return hr;
	}
	pRs->put_CursorLocation(adUseClient);
    hr = pRs->Open( vSql, 
			   _variant_t((IDispatch *)m_connection,true),
			   adOpenStatic, adLockBatchOptimistic, adCmdText);

	if(!SUCCEEDED(hr))
	{
		MessageBox(NULL, L"Can't  Clone  Recordset!", L"Pos Server Error!", MB_OK);
		return hr;
	}

	pRs->putref_ActiveConnection(NULL);

	*ppRecordset = (IDispatch *)pRs.Detach();

	return hr;
}

STDMETHODIMP CPos_ADO::CancelBatch()
{
	// TODO: Add your implementation code here
	return m_recordset->CancelBatch(adAffectAll);
}

STDMETHODIMP CPos_ADO::Cancel()
{
	// TODO: Add your implementation code here
	return m_recordset->Cancel();
}

STDMETHODIMP CPos_ADO::CancelUpdate()
{
	// TODO: Add your implementation code here
	return m_recordset->CancelUpdate();
}

STDMETHODIMP CPos_ADO::AddNew(VARIANT FieldList, VARIANT Values)
{
	// TODO: Add your implementation code here
	return m_recordset->AddNew(FieldList, Values);
}

STDMETHODIMP CPos_ADO::Find(BSTR Criteria)
{
	// TODO: Add your implementation code here
	HRESULT hr;
	hr = m_recordset->Find(Criteria, 0, adSearchForward);
	return hr;
}

STDMETHODIMP CPos_ADO::get_BookMark(VARIANT *pVal)
{
	// TODO: Add your implementation code here
	HRESULT hr;
	hr = m_recordset->get_Bookmark(pVal);
	return hr;
}

STDMETHODIMP CPos_ADO::put_BookMark(VARIANT newVal)
{
	// TODO: Add your implementation code here
	HRESULT hr;
	hr = m_recordset->put_Bookmark(newVal);
	return hr;
}

STDMETHODIMP CPos_ADO::get_FieldName(VARIANT idx, BSTR *pVal)
{
	// TODO: Add your implementation code here
	Fields* fields = 0;
	HRESULT hr = m_recordset->get_Fields(&fields);
	Field* field = 0;
	if (SUCCEEDED(hr))
		hr = fields->get_Item(idx, &field);
	if (SUCCEEDED(hr))
		hr = field->get_Name(pVal);

	if (SUCCEEDED(hr))
	{
		fields->Release();
		field->Release();
	}
	return hr;
	return S_OK;
}

STDMETHODIMP CPos_ADO::get_FieldDefSize(VARIANT idx, long *pVal)
{
	// TODO: Add your implementation code here
	Fields* fields = 0;
	HRESULT hr = m_recordset->get_Fields(&fields);
	Field* field = 0;
	if (SUCCEEDED(hr))
		hr = fields->get_Item(idx, &field);
	if (SUCCEEDED(hr))
		hr = field->get_DefinedSize(pVal);

	if (SUCCEEDED(hr))
	{
		fields->Release();
		field->Release();
	}
	return hr;
}