igetasadorecordsetimpl.h

The ATL OLE DB Provider templates only seem to support read-only rowsets and making them support upd

#ifndef __IGETASADORECORDSETIMPL__INCLUDED__
#define __IGETASADORECORDSETIMPL__INCLUDED__

#include "IGetAsADORecordset.h"

#import "D:\Program Files\Common Files\System\ado\msado15.dll" rename( "EOF", "adoEOF" ) 

///////////////////////////////////////////////////////////////////////////////
// Helper function that does the work and doesnt need to be templatised.
///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP IGetAsADORecordsetImpl_GetAsRecordSetHelper(
   LPCTSTR lpszProvider,
   IUnknown *pUnknown, 
   CursorLocationEnum cusorLocation,
   LockTypeEnum lockType,
   CursorTypeEnum cursorType,
   IUnknown *pRecordset);

HRESULT IGetAsADORecordsetImpl_GetRecordset(
   IUnknown *pUnkOuter,
   REFIID riid,
   IUnknown **ppRecordset,
   IUnknown **ppUnknown);


///////////////////////////////////////////////////////////////////////////////

DEFINE_GUID(IID_IDataSource,0x7c0ffab3L, 0xcd84, 0x11d0, 0x94, 0x9a, 0x00, 0xa0, 0xc9, 0x11, 0x10, 0xed);

///////////////////////////////////////////////////////////////////////////////
// IGetAsADORecordsetImpl
///////////////////////////////////////////////////////////////////////////////

template <
   class T, 
   const GUID* plibid = &CComModule::m_libid, 
   WORD wMajor = 1,
   WORD wMinor = 0, 
   class tihclass = CComTypeInfoHolder>
class ATL_NO_VTABLE IGetAsADORecordsetImpl 
   :  public IDispatchImpl<
         IGetAsADORecordset, 
         &IID_IGetAsADORecordset, 
         plibid, 
         wMajor, 
         wMinor, 
         tihclass>
{
   public:

   typedef IGetAsADORecordsetImpl<T, plibid, wMajor, wMinor, tihclass> ThisClass;


BEGIN_COM_MAP(ThisClass)
	COM_INTERFACE_ENTRY(IGetAsADORecordset)
   COM_INTERFACE_ENTRY_FUNC(__uuidof(ADODB::_Recordset), 0, ThisClass::InternalADOTearOffQIFunc) 
   COM_INTERFACE_ENTRY_FUNC(__uuidof(ADODB::Recordset15), 0, ThisClass::InternalADOTearOffQIFunc) 
   COM_INTERFACE_ENTRY_FUNC(__uuidof(ADODB::Recordset20), 0, ThisClass::InternalADOTearOffQIFunc) 
   COM_INTERFACE_ENTRY_FUNC(IID_IDataSource, 0, ThisClass::InternalADOTearOffQIFunc)
   COM_INTERFACE_ENTRY_FUNC_BLIND(1, ThisClass::InternalADOTearOffQIFunc)
END_COM_MAP()


      STDMETHOD(GetAsRecordset)(
         CursorLocationEnum cursorLocation,        // [in, optional, defaultvalue(adUseClient)]
         LockTypeEnum lockType,                    // [in, optional, defaultvalue(adLockReadOnly)]
         CursorTypeEnum cursorType,                // [in, optional, defaultvalue(adOpenStatic)]
         VARIANT *pvRecordset)                     // [out, retval]
      {
         if (!pvRecordset)
         {
            return E_POINTER;
         }

         IUnknown *pRecordset = 0;

         HRESULT hr = IGetAsADORecordsetImpl_GetRecordset(
            0, 
            __uuidof(ADODB::Recordset15), 
            &pRecordset, 
            0);

         if (SUCCEEDED(hr))
         {

            hr = GetAsRecordset(
               cursorLocation, 
               lockType, 
               cursorType, 
               pRecordset);

            if (SUCCEEDED(hr))
            {
               // Return the recordset in a variant...
               pvRecordset->vt = VT_DISPATCH;
	            pvRecordset->pdispVal = (IDispatch*)pRecordset;
            }
         }

         return hr;
      }

      static HRESULT WINAPI ADOTearOffQIFunc(
         void* pv, 
         REFIID riid, 
         LPVOID* ppv, 
         DWORD dw)
      {
         T *pT = (T*)pv;

         ThisClass *pMe = (ThisClass*)pT;

         return pMe->QIForTearOffRecordset(riid, ppv, dw);
      }

   protected :
   
      IGetAsADORecordsetImpl()
         :  m_pADORecordset(0)
      {

      }

   private :

      static HRESULT WINAPI InternalADOTearOffQIFunc(
         void* pv, 
         REFIID riid, 
         LPVOID* ppv, 
         DWORD dw)
      {
         if (dw == 1)
         {
            return _ATLDUMPIID(riid, _T("IGetAsADORecordsetImpl"), E_NOINTERFACE);
         }

         ThisClass *pMe = (ThisClass*)pv;

         return pMe->QIForTearOffRecordset(riid, ppv, dw);
      }

      HRESULT QIForTearOffRecordset(REFIID riid, LPVOID* ppv, DWORD dw)
      {
         HRESULT hr = S_OK;

         if (!m_pADORecordset)
         {
            IUnknown *pThis = 0;

            hr = QueryInterface(IID_IUnknown, (void**)&pThis);

            if (SUCCEEDED(hr))
            {
               IUnknown *pRecordset = 0;

               hr = IGetAsADORecordsetImpl_GetRecordset(
                  pThis, 
                  riid, 
                  &pRecordset, 
                  &m_pADORecordset);

               if (SUCCEEDED(hr))
               {
                  m_pADORecordset->AddRef();

                  hr = GetAsRecordset(
                     adUseServer,
                     adLockOptimistic,
                     adOpenDynamic,
                     pRecordset);
               }
            }
         }

         if (SUCCEEDED(hr))
         {
            hr = m_pADORecordset->QueryInterface(riid, ppv); 
         }

         return hr;
      }
   
      HRESULT GetAsRecordset(
         CursorLocationEnum cursorLocation,        
         LockTypeEnum lockType,                    
         CursorTypeEnum cursorType,                
         IUnknown *pRecordset)                     
      {
         // Get at our object's IUnknown interface...

         T *pT = (T*)this;
         
         IUnknown *pUnknown = 0;

         HRESULT hr = pT->QueryInterface(IID_IUnknown, (void**)&pUnknown);

         if (SUCCEEDED(hr))
         {
            // Go do the work...

            hr = IGetAsADORecordsetImpl_GetAsRecordSetHelper(
               _T("Provider=SimpleDataObject.ConversionProvider.1"),
               pUnknown,  
               cursorLocation,
               lockType,
               cursorType,
               pRecordset);

            pUnknown->Release();
         }

         return hr;
      }

      
      IUnknown *m_pADORecordset;

};


#endif // __IGETASADORECORDSETIMPL__INCLUDED__