home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / com / adosamp / server / adotier.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-03  |  7.8 KB  |  329 lines
  1. // Copyright (C) 1992-1998 Microsoft Corporation
  2. // All rights reserved.
  3. //
  4. // This source code is only intended as a supplement to the
  5. // Microsoft Visual C++ Language  Reference and related
  6. // electronic documentation provided with Microsoft Visual C++.
  7. // See these sources for detailed information regarding the
  8. // Microsoft Visual C++ product.
  9.  
  10. // ADOTier.cpp : Implementation of CADOSampApp and DLL registration.
  11.  
  12. #include "stdafx.h"
  13. #include "ADOTier.h"
  14.  
  15. /////////////////////////////////////////////////////////////////////////////
  16. //
  17.  
  18. // Need two distinct "empty" VARIANTs for Command::Execute
  19. static VARIANT* pvtEmpty = static_cast<VARIANT*> (&vtMissing);
  20. static _variant_t vtMissing2(DISP_E_PARAMNOTFOUND, VT_ERROR);
  21. static VARIANT* pvtEmpty2 = static_cast<VARIANT*> (&vtMissing2);
  22.  
  23. STDMETHODIMP CADOTier::InterfaceSupportsErrorInfo(REFIID riid)
  24. {
  25.     static const IID* arr[] =
  26.     {
  27.         &IID_IADOTier,
  28.     };
  29.  
  30.     for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
  31.     {
  32.         if (InlineIsEqualGUID(*arr[i],riid))
  33.             return S_OK;
  34.     }
  35.     return S_FALSE;
  36. }
  37.  
  38. STDMETHODIMP CADOTier::Open(BSTR source, BSTR user, BSTR pwd)
  39. {
  40.     HRESULT hr = m_connection.CreateInstance("ADODB.Connection.1");
  41.     if (SUCCEEDED(hr))
  42.         hr = m_connection->Open(source, user, pwd);
  43.     if (SUCCEEDED(hr))
  44.         hr = m_command.CreateInstance(__uuidof(Command));
  45.     if (SUCCEEDED(hr))
  46.         hr = m_command->putref_ActiveConnection(m_connection);
  47.     if (SUCCEEDED(hr))
  48.         hr = m_recordset.CreateInstance(__uuidof(Recordset));
  49.  
  50.     return hr;
  51. }
  52.  
  53. STDMETHODIMP CADOTier::OpenRecordset(VARIANT query)
  54. {
  55.     VARIANT v;
  56.     V_VT(&v) = VT_DISPATCH;
  57.     V_DISPATCH(&v) = (IDispatch*) m_connection;
  58.  
  59.     // Need the AddRef() as VariantClear() calls Release(), unless fAddRef
  60.     // false indicates we're taking ownership
  61.     //
  62.     V_DISPATCH(&v)->AddRef();
  63.  
  64.     return m_recordset->Open(query, v, adOpenDynamic, adLockOptimistic, adCmdText);
  65. }
  66.  
  67. STDMETHODIMP CADOTier::CloseRecordset()
  68. {
  69.     return m_recordset->Close();
  70. }
  71.  
  72. STDMETHODIMP CADOTier::ExecuteConnection(BSTR query, VARIANT_BOOL bChangeRec)
  73. {
  74.     _Recordset* prec = 0;
  75.     HRESULT hr = m_connection->Execute(query, pvtEmpty, adCmdText, &prec);
  76.     if (SUCCEEDED(hr))
  77.     {
  78.         if (bChangeRec)
  79.             m_recordset = prec;
  80.         else
  81.             prec->Release();
  82.     }
  83.     return hr;
  84. }
  85.  
  86. STDMETHODIMP CADOTier::ExecuteCommand(VARIANT_BOOL bStoredProcedure, VARIANT_BOOL bChangeRec)
  87. {
  88.     _Recordset* prec = 0;
  89.     HRESULT hr;
  90.     if (bStoredProcedure)
  91.         hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdStoredProc, &prec);
  92.     else
  93.         hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
  94.     if (SUCCEEDED(hr))
  95.     {
  96.         if (bChangeRec)
  97.             m_recordset = prec;
  98.         else
  99.             prec->Release();
  100.     }
  101.     return hr;
  102. }
  103.  
  104. STDMETHODIMP CADOTier::get_CommandText(BSTR * newVal)
  105. {
  106.     return m_command->get_CommandText(newVal);
  107. }
  108.  
  109. STDMETHODIMP CADOTier::put_CommandText(BSTR newVal)
  110. {
  111.     return m_command->put_CommandText(newVal);
  112. }
  113.  
  114. STDMETHODIMP CADOTier::AppendParameter(enum DataTypeEnum type, VARIANT value, enum ParameterDirectionEnum where, long size)
  115. {
  116.     _ParameterPtr param;
  117.     HRESULT hr = param.CreateInstance(__uuidof(Parameter));
  118.     if (SUCCEEDED(hr))
  119.         hr = param->put_Type(type);
  120.     if (SUCCEEDED(hr))
  121.         hr = param->put_Value(value);
  122.     if (SUCCEEDED(hr))
  123.         hr = param->put_Direction(where);
  124.     if (SUCCEEDED(hr))
  125.         hr = param->put_Size(size);
  126.  
  127.     Parameters* params = 0;
  128.     if (SUCCEEDED(hr))
  129.         hr = m_command->get_Parameters(¶ms);
  130.     if (SUCCEEDED(hr))
  131.         hr = params->Append(param);
  132.  
  133.     if (SUCCEEDED(hr))
  134.     {
  135.         params->Release();
  136.         param->Release();
  137.     }
  138.     return hr;
  139. }
  140.  
  141. STDMETHODIMP CADOTier::Update()
  142. {
  143.     return m_recordset->Update();
  144. }
  145.  
  146. STDMETHODIMP CADOTier::Delete()
  147. {
  148.     return m_recordset->Delete(adAffectCurrent);
  149. }
  150.  
  151. STDMETHODIMP CADOTier::get_Field(VARIANT idx, VARIANT * newVal)
  152. {
  153.     Fields* fields = 0;
  154.     HRESULT hr = m_recordset->get_Fields(&fields);
  155.     Field* field = 0;
  156.     if (SUCCEEDED(hr))
  157.         hr = fields->get_Item(idx, &field);
  158.     if (SUCCEEDED(hr))
  159.         hr = field->get_Value(newVal);
  160.  
  161.     if (SUCCEEDED(hr))
  162.     {
  163.         fields->Release();
  164.         field->Release();
  165.     }
  166.     return hr;
  167. }
  168.  
  169. STDMETHODIMP CADOTier::put_Field(VARIANT idx, VARIANT newVal)
  170. {
  171.     Fields* fields = 0;
  172.     HRESULT hr = m_recordset->get_Fields(&fields);
  173.     Field* field = 0;
  174.     if (SUCCEEDED(hr))
  175.         hr = fields->get_Item(idx, &field);
  176.     if (SUCCEEDED(hr))
  177.         hr = field->put_Value(newVal);
  178.  
  179.     if (SUCCEEDED(hr))
  180.     {
  181.         fields->Release();
  182.         field->Release();
  183.     }
  184.     return hr;
  185. }
  186.  
  187. STDMETHODIMP CADOTier::get_FieldCount(long * newVal)
  188. {
  189.     Fields* fields = 0;
  190.     HRESULT hr = m_recordset->get_Fields(&fields);
  191.     if (SUCCEEDED(hr))
  192.         hr = fields->get_Count(newVal);
  193.     if (SUCCEEDED(hr))
  194.         fields->Release();
  195.     return hr;
  196. }
  197.  
  198. STDMETHODIMP CADOTier::Close()
  199. {
  200.     return m_connection->Close();
  201. }
  202.  
  203. STDMETHODIMP CADOTier::First()
  204. {
  205.     return m_recordset->MoveFirst();
  206. }
  207.  
  208. STDMETHODIMP CADOTier::Next()
  209. {
  210.     return m_recordset->MoveNext();
  211. }
  212.  
  213. STDMETHODIMP CADOTier::Last()
  214. {
  215.     return m_recordset->MoveLast();
  216. }
  217.  
  218. STDMETHODIMP CADOTier::Prev()
  219. {
  220.     return m_recordset->MovePrevious();
  221. }
  222.  
  223. STDMETHODIMP CADOTier::get_EOF(VARIANT_BOOL * newVal)
  224. {
  225.     return m_recordset->get_EOF(newVal);
  226. }
  227.  
  228. STDMETHODIMP CADOTier::get_BOF(VARIANT_BOOL * newVal)
  229. {
  230.     return m_recordset->get_BOF(newVal);
  231. }
  232.  
  233. STDMETHODIMP CADOTier::ParamQuery(BSTR query, long idx1, BSTR idx2, BSTR idx3)
  234. {
  235.     HRESULT hr = ChangeParameter(0, adInteger, (_variant_t) idx1, adParamInput, -1);
  236.     if (SUCCEEDED(hr))
  237.         hr = ChangeParameter(1, adVarChar, (_variant_t) idx2, adParamInput, 25);
  238.     if (SUCCEEDED(hr))
  239.         hr = ChangeParameter(2, adVarChar, (_variant_t) idx3, adParamInput, 80);
  240.     if (SUCCEEDED(hr))
  241.         hr = m_command->put_CommandText(query);
  242.     _Recordset* prec = 0;
  243.     if (SUCCEEDED(hr))
  244.         hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
  245.     if (SUCCEEDED(hr))
  246.         prec->Release();
  247.     return hr;
  248. }
  249.  
  250. STDMETHODIMP CADOTier::CallStoredProc(long idx1, BSTR idx2, BSTR idx3)
  251. {
  252.     HRESULT hr = ChangeParameter(0, adInteger, (_variant_t) idx1, adParamInput, 4);
  253.     if (SUCCEEDED(hr))
  254.         hr = ChangeParameter(1, adVarChar, (_variant_t) idx2, adParamInput, 25);
  255.     if (SUCCEEDED(hr))
  256.         hr = ChangeParameter(2, adVarChar, (_variant_t) idx3, adParamInput, 80);
  257.     if (SUCCEEDED(hr))
  258.         hr = m_command->put_CommandText(L"{call MyProc (?, ?, ?)}");
  259.     _Recordset* prec = 0;
  260.     if (SUCCEEDED(hr))
  261.         hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
  262.     if (SUCCEEDED(hr))
  263.         prec->Release();
  264.     return hr;
  265. }
  266.  
  267. STDMETHODIMP CADOTier::put_StoredProc(BSTR newVal)
  268. {
  269.     if (newVal == NULL)
  270.         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");
  271.     HRESULT hr = m_command->put_CommandText(newVal);
  272.     _Recordset* prec = 0;
  273.     if (SUCCEEDED(hr))
  274.         hr = m_command->Execute(pvtEmpty, pvtEmpty2, adCmdText, &prec);
  275.     if (SUCCEEDED(hr))
  276.         prec->Release();
  277.     return hr;
  278. }
  279.  
  280.  
  281. STDMETHODIMP CADOTier::ChangeParameter(long idx, enum DataTypeEnum type, VARIANT value, enum ParameterDirectionEnum where, long size)
  282. {
  283.     Parameters* params = 0;
  284.     HRESULT hr = m_command->get_Parameters(¶ms);
  285.  
  286.     _Parameter* param = 0;
  287.     VARIANT v;
  288.     V_VT(&v) = VT_I4;
  289.     V_I4(&v) = idx;
  290.     if (SUCCEEDED(hr))
  291.         hr = params->get_Item(v, ¶m);
  292.  
  293.     if (SUCCEEDED(hr))
  294.         hr = param->put_Type(type);
  295.     if (SUCCEEDED(hr))
  296.         hr = param->put_Value(value);
  297.     if (SUCCEEDED(hr))
  298.         hr = param->put_Direction(where);
  299.     if (SUCCEEDED(hr))
  300.         hr = param->put_Size(size);
  301.     if (SUCCEEDED(hr))
  302.     {
  303.         params->Release();
  304.         param->Release();
  305.     }
  306.     return hr;
  307. }
  308.  
  309. STDMETHODIMP CADOTier::Requery()
  310. {
  311.     return m_recordset->Requery();
  312. }
  313.  
  314. STDMETHODIMP CADOTier::ADORelease()
  315. {
  316.     m_command = 0;
  317.     m_recordset = 0;
  318.     m_connection = 0;
  319.     return S_OK;
  320. }
  321.  
  322. STDMETHODIMP CADOTier::get_Empty(VARIANT_BOOL * bEmpty)
  323. {
  324.     HRESULT hr = m_recordset->get_EOF(bEmpty);
  325.     if (SUCCEEDED(hr) && bEmpty)
  326.         hr = m_recordset->get_BOF(bEmpty);
  327.     return hr;
  328. }
  329.