dlls/msdasql/session.c

   1 /*
   2  * Copyright 2020 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "objbase.h"
  26 #include "rpcproxy.h"
  27 #include "msdasc.h"
  28 #include "wine/heap.h"
  29 #include "wine/debug.h"
  30
  31 #include "msdasql.h"
  32 #include "oledberr.h"
  33 #include "sqlucode.h"
  34
  35 #include "msdasql_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(msdasql);
  38
  39 struct msdasql_prop
  40 {
  41     DBPROPID    property_id;
  42     DBPROPFLAGS flags;
  43     VARTYPE     vartype;
  44
  45     LONG value;
  46 };
  47
  48 static struct msdasql_prop msdasql_init_props[] =
  49 {
  50     { DBPROP_ABORTPRESERVE,                   DBPROPFLAGS_ROWSET | DBPROPFLAGS_DATASOURCEINFO, VT_BOOL, VARIANT_FALSE },
  51     { DBPROP_BLOCKINGSTORAGEOBJECTS,          DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  52     { DBPROP_BOOKMARKS,                       DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  53     { DBPROP_BOOKMARKSKIPPED,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  54     { DBPROP_BOOKMARKTYPE,                    DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_I4, 1 },
  55     { DBPROP_CANFETCHBACKWARDS,               DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  56     { DBPROP_CANHOLDROWS,                     DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  57     { DBPROP_CANSCROLLBACKWARDS,              DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  58     { DBPROP_COLUMNRESTRICT,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  59     { DBPROP_COMMITPRESERVE,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  60     { DBPROP_DELAYSTORAGEOBJECTS,             DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  61     { DBPROP_IMMOBILEROWS,                    DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_TRUE },
  62     { DBPROP_LITERALBOOKMARKS,                DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  63     { DBPROP_LITERALIDENTITY,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  64     { DBPROP_MAXOPENROWS,                     DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4, 0 },
  65     { DBPROP_MAXPENDINGROWS,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_I4,  0 },
  66     { DBPROP_MAXROWS,                         DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_I4, 0 },
  67     { DBPROP_NOTIFICATIONPHASES,              DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4, 31 },
  68     { DBPROP_OTHERUPDATEDELETE,               DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  69     { DBPROP_OWNINSERT,                       DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  70     { DBPROP_OWNUPDATEDELETE,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  71     { DBPROP_QUICKRESTART ,                   DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  72     { DBPROP_REENTRANTEVENTS,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  73     { DBPROP_REMOVEDELETED,                   DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  74     { DBPROP_REPORTMULTIPLECHANGES,           DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  75     { DBPROP_ROWRESTRICT,                     DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  76     { DBPROP_ROWTHREADMODEL,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4, 2 },
  77     { DBPROP_TRANSACTEDOBJECT,                DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  78     { DBPROP_UPDATABILITY,                    DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4, 0 },
  79     { DBPROP_STRONGIDENTITY,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  80     { DBPROP_IAccessor,                       DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  81     { DBPROP_IColumnsInfo,                    DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  82     { DBPROP_IColumnsRowset,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  83     { DBPROP_IConnectionPointContainer,       DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  84     { DBPROP_IRowset,                         DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  85     { DBPROP_IRowsetChange,                   DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  86     { DBPROP_IRowsetIdentity,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  87     { DBPROP_IRowsetInfo,                     DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  88     { DBPROP_IRowsetLocate,                   DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  89     { DBPROP_IRowsetResynch,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  90     { DBPROP_IRowsetUpdate,                   DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
  91     { DBPROP_ISupportErrorInfo,               DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
  92     { DBPROP_ISequentialStream,               DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
  93     { DBPROP_NOTIFYCOLUMNSET,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
  94     { DBPROP_NOTIFYROWDELETE,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
  95     { DBPROP_NOTIFYROWFIRSTCHANGE,            DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
  96     { DBPROP_NOTIFYROWINSERT,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
  97     { DBPROP_NOTIFYROWRESYNCH,                DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
  98     { DBPROP_NOTIFYROWSETRELEASE,             DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
  99     { DBPROP_NOTIFYROWSETFETCHPOSITIONCHANGE, DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
 100     { DBPROP_NOTIFYROWUNDOCHANGE,             DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
 101     { DBPROP_NOTIFYROWUNDODELETE,             DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
 102     { DBPROP_NOTIFYROWUNDOINSERT,             DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
 103     { DBPROP_NOTIFYROWUPDATE,                 DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4,  3 },
 104     { DBPROP_CHANGEINSERTEDROWS,              DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_TRUE },
 105     { DBPROP_RETURNPENDINGINSERTS,            DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
 106     { DBPROP_IConvertType,                    DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_BOOL, VARIANT_TRUE },
 107     { DBPROP_NOTIFICATIONGRANULARITY,         DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_I4, 1 },
 108     { DBPROP_IMultipleResults,                DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 109     { DBPROP_ACCESSORDER,                     DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_I4, 1 },
 110     { DBPROP_BOOKMARKINFO,                    DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4, 0 },
 111     { DBPROP_UNIQUEROWS,                      DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 112     { DBPROP_IRowsetFind,                     DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 113     { DBPROP_IRowsetScroll,                   DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_TRUE },
 114     { DBPROP_IRowsetRefresh,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_TRUE },
 115     { DBPROP_FINDCOMPAREOPS,                  DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ, VT_I4, 27 },
 116     { DBPROP_ORDEREDBOOKMARKS,                DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_TRUE },
 117     { DBPROP_CLIENTCURSOR,                    DBPROPFLAGS_ROWSET | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_TRUE },
 118     { DBPROP_ABORTPRESERVE,                   DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 119     { DBPROP_ACTIVESESSIONS,                  DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
 120     { DBPROP_ASYNCTXNCOMMIT,                  DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ, VT_BOOL, VARIANT_FALSE },
 121     { DBPROP_AUTH_CACHE_AUTHINFO,             DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 122     { DBPROP_AUTH_ENCRYPT_PASSWORD,           DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_I4, 0 },
 123     { DBPROP_AUTH_INTEGRATED,                 DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_I4, 14 },
 124     { DBPROP_AUTH_MASK_PASSWORD,              DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 125     { DBPROP_AUTH_PASSWORD,                   DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 126     { DBPROP_AUTH_PERSIST_ENCRYPTED,          DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 127     { DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO, DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 128     { DBPROP_AUTH_USERID,                     DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 129     { DBPROP_BLOCKINGSTORAGEOBJECTS,          DBPROPFLAGS_DATASOURCEINFO | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE, VT_BOOL, VARIANT_FALSE },
 130 };
 131
 132 struct msdasql_session
 133 {
 134     IUnknown session_iface;
 135     IGetDataSource IGetDataSource_iface;
 136     IOpenRowset    IOpenRowset_iface;
 137     ISessionProperties ISessionProperties_iface;
 138     IDBCreateCommand IDBCreateCommand_iface;
 139     ITransactionJoin ITransactionJoin_iface;
 140     ITransaction ITransaction_iface;
 141     LONG refs;
 142
 143     IUnknown *datasource;
 144
 145     HDBC hdbc;
 146 };
 147
 148 static inline struct msdasql_session *impl_from_IUnknown( IUnknown *iface )
 149 {
 150     return CONTAINING_RECORD( iface, struct msdasql_session, session_iface );
 151 }
 152
 153 static inline struct msdasql_session *impl_from_IGetDataSource( IGetDataSource *iface )
 154 {
 155     return CONTAINING_RECORD( iface, struct msdasql_session, IGetDataSource_iface );
 156 }
 157
 158 static inline struct msdasql_session *impl_from_IOpenRowset( IOpenRowset *iface )
 159 {
 160     return CONTAINING_RECORD( iface, struct msdasql_session, IOpenRowset_iface );
 161 }
 162
 163 static inline struct msdasql_session *impl_from_ISessionProperties( ISessionProperties *iface )
 164 {
 165     return CONTAINING_RECORD( iface, struct msdasql_session, ISessionProperties_iface );
 166 }
 167
 168 static inline struct msdasql_session *impl_from_IDBCreateCommand( IDBCreateCommand *iface )
 169 {
 170     return CONTAINING_RECORD( iface, struct msdasql_session, IDBCreateCommand_iface );
 171 }
 172
 173 static inline struct msdasql_session *impl_from_ITransactionJoin( ITransactionJoin *iface )
 174 {
 175     return CONTAINING_RECORD( iface, struct msdasql_session, ITransactionJoin_iface );
 176 }
 177
 178 static inline struct msdasql_session *impl_from_ITransaction( ITransaction *iface )
 179 {
 180     return CONTAINING_RECORD( iface, struct msdasql_session, ITransaction_iface );
 181 }
 182
 183 static HRESULT WINAPI session_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 184 {
 185     struct msdasql_session *session = impl_from_IUnknown( iface );
 186
 187     TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), ppv );
 188     *ppv = NULL;
 189
 190     if(IsEqualGUID(&IID_IUnknown, riid))
 191     {
 192         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 193         *ppv = &session->session_iface;
 194     }
 195     else if(IsEqualGUID(&IID_IGetDataSource, riid))
 196     {
 197         TRACE("(%p)->(IID_IGetDataSource %p)\n", iface, ppv);
 198         *ppv = &session->IGetDataSource_iface;
 199     }
 200     else if(IsEqualGUID(&IID_IOpenRowset, riid))
 201     {
 202         TRACE("(%p)->(IID_IOpenRowset %p)\n", iface, ppv);
 203         *ppv = &session->IOpenRowset_iface;
 204     }
 205     else if(IsEqualGUID(&IID_ISessionProperties, riid))
 206     {
 207         TRACE("(%p)->(IID_ISessionProperties %p)\n", iface, ppv);
 208         *ppv = &session->ISessionProperties_iface;
 209     }
 210     else if(IsEqualGUID(&IID_IDBCreateCommand, riid))
 211     {
 212         TRACE("(%p)->(IDBCreateCommand_iface %p)\n", iface, ppv);
 213         *ppv = &session->IDBCreateCommand_iface;
 214     }
 215     else if(IsEqualGUID(&IID_ITransactionJoin, riid))
 216     {
 217         TRACE("(%p)->(ITransactionJoin %p)\n", iface, ppv);
 218         *ppv = &session->ITransactionJoin_iface;
 219     }
 220     else if(IsEqualGUID(&IID_ITransaction, riid))
 221     {
 222         TRACE("(%p)->(ITransaction %p)\n", iface, ppv);
 223         *ppv = &session->ITransaction_iface;
 224     }
 225     else if(IsEqualGUID(&IID_IBindResource, riid))
 226     {
 227         TRACE("(%p)->(IID_IBindResource not support)\n", iface);
 228         return E_NOINTERFACE;
 229     }
 230     else if(IsEqualGUID(&IID_ICreateRow, riid))
 231     {
 232         TRACE("(%p)->(IID_ICreateRow not support)\n", iface);
 233         return E_NOINTERFACE;
 234     }
 235
 236     if(*ppv)
 237     {
 238         IUnknown_AddRef((IUnknown*)*ppv);
 239         return S_OK;
 240     }
 241
 242     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 243     return E_NOINTERFACE;
 244 }
 245
 246 static ULONG WINAPI session_AddRef(IUnknown *iface)
 247 {
 248     struct msdasql_session *session = impl_from_IUnknown( iface );
 249     LONG refs = InterlockedIncrement( &session->refs );
 250     TRACE( "%p new refcount %ld\n", session, refs );
 251     return refs;
 252 }
 253
 254 static ULONG WINAPI session_Release(IUnknown *iface)
 255 {
 256     struct msdasql_session *session = impl_from_IUnknown( iface );
 257     LONG refs = InterlockedDecrement( &session->refs );
 258     TRACE( "%p new refcount %ld\n", session, refs );
 259     if (!refs)
 260     {
 261         TRACE( "destroying %p\n", session );
 262
 263         IUnknown_Release(session->datasource);
 264         heap_free( session );
 265     }
 266     return refs;
 267 }
 268
 269 static const IUnknownVtbl unkfactoryVtbl =
 270 {
 271     session_QueryInterface,
 272     session_AddRef,
 273     session_Release,
 274 };
 275
 276
 277 HRESULT WINAPI datasource_QueryInterface(IGetDataSource *iface, REFIID riid, void **out)
 278 {
 279     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 280     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 281 }
 282
 283 ULONG WINAPI datasource_AddRef(IGetDataSource *iface)
 284 {
 285     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 286     return IUnknown_AddRef(&session->session_iface);
 287 }
 288
 289 ULONG WINAPI datasource_Release(IGetDataSource *iface)
 290 {
 291     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 292     return IUnknown_Release(&session->session_iface);
 293 }
 294
 295 HRESULT WINAPI datasource_GetDataSource(IGetDataSource *iface, REFIID riid, IUnknown **datasource)
 296 {
 297     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 298
 299     TRACE("%p, %s, %p stub\n", session, debugstr_guid(riid), datasource);
 300
 301     if (!datasource)
 302         return E_INVALIDARG;
 303
 304     return IUnknown_QueryInterface(session->datasource, riid, (void**)datasource);
 305 }
 306
 307 static const IGetDataSourceVtbl datasourceVtbl =
 308 {
 309     datasource_QueryInterface,
 310     datasource_AddRef,
 311     datasource_Release,
 312     datasource_GetDataSource
 313 };
 314
 315 HRESULT WINAPI openrowset_QueryInterface(IOpenRowset *iface, REFIID riid, void **out)
 316 {
 317     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 318     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 319 }
 320
 321 ULONG WINAPI openrowset_AddRef(IOpenRowset *iface)
 322 {
 323     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 324     return IUnknown_AddRef(&session->session_iface);
 325 }
 326
 327 ULONG WINAPI openrowset_Release(IOpenRowset *iface)
 328 {
 329     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 330     return IUnknown_Release(&session->session_iface);
 331 }
 332
 333 HRESULT WINAPI openrowset_OpenRowset(IOpenRowset *iface, IUnknown *pUnkOuter, DBID *table,
 334             DBID *index, REFIID riid, ULONG count, DBPROPSET propertysets[], IUnknown **rowset)
 335 {
 336     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 337     FIXME("%p, %p, %p %p %s, %ld %p %p stub\n", session, pUnkOuter, table, index, debugstr_guid(riid),
 338             count, propertysets, rowset);
 339
 340     return E_NOTIMPL;
 341 }
 342
 343 static const IOpenRowsetVtbl openrowsetVtbl =
 344 {
 345     openrowset_QueryInterface,
 346     openrowset_AddRef,
 347     openrowset_Release,
 348     openrowset_OpenRowset
 349 };
 350
 351 static HRESULT WINAPI properties_QueryInterface(ISessionProperties *iface, REFIID riid, void **out)
 352 {
 353     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 354     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 355 }
 356
 357 static ULONG WINAPI properties_AddRef(ISessionProperties *iface)
 358 {
 359     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 360     return IUnknown_AddRef(&session->session_iface);
 361 }
 362
 363 static ULONG WINAPI properties_Release(ISessionProperties *iface)
 364 {
 365     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 366     return IUnknown_Release(&session->session_iface);
 367 }
 368
 369
 370 static HRESULT WINAPI properties_GetProperties(ISessionProperties *iface, ULONG set_count,
 371     const DBPROPIDSET id_sets[], ULONG *count, DBPROPSET **sets)
 372 {
 373     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 374     FIXME("%p %lu %p %p %p\n", session, set_count, id_sets, count, sets);
 375
 376     return E_NOTIMPL;
 377 }
 378
 379 static HRESULT WINAPI properties_SetProperties(ISessionProperties *iface, ULONG count,
 380     DBPROPSET sets[])
 381 {
 382     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 383     FIXME("%p %lu %p\n", session, count, sets);
 384
 385     return S_OK;
 386 }
 387
 388 static const ISessionPropertiesVtbl propertiesVtbl =
 389 {
 390     properties_QueryInterface,
 391     properties_AddRef,
 392     properties_Release,
 393     properties_GetProperties,
 394     properties_SetProperties
 395 };
 396
 397 static HRESULT WINAPI createcommand_QueryInterface(IDBCreateCommand *iface, REFIID riid, void **out)
 398 {
 399     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
 400     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 401 }
 402
 403 static ULONG WINAPI createcommand_AddRef(IDBCreateCommand *iface)
 404 {
 405     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
 406     return IUnknown_AddRef(&session->session_iface);
 407 }
 408
 409 static ULONG WINAPI createcommand_Release(IDBCreateCommand *iface)
 410 {
 411     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
 412     return IUnknown_Release(&session->session_iface);
 413 }
 414
 415 struct command
 416 {
 417     ICommandText ICommandText_iface;
 418     ICommandProperties ICommandProperties_iface;
 419     IColumnsInfo IColumnsInfo_iface;
 420     IConvertType IConvertType_iface;
 421     ICommandPrepare ICommandPrepare_iface;
 422     ICommandWithParameters ICommandWithParameters_iface;
 423     LONG refs;
 424     WCHAR *query;
 425     IUnknown *session;
 426     HDBC hdbc;
 427     SQLHSTMT hstmt;
 428
 429     struct msdasql_prop *properties;
 430     LONG prop_count;
 431 };
 432
 433 static inline struct command *impl_from_ICommandText( ICommandText *iface )
 434 {
 435     return CONTAINING_RECORD( iface, struct command, ICommandText_iface );
 436 }
 437
 438 static inline struct command *impl_from_ICommandProperties( ICommandProperties *iface )
 439 {
 440     return CONTAINING_RECORD( iface, struct command, ICommandProperties_iface );
 441 }
 442
 443 static inline struct command *impl_from_IColumnsInfo( IColumnsInfo *iface )
 444 {
 445     return CONTAINING_RECORD( iface, struct command, IColumnsInfo_iface );
 446 }
 447
 448 static inline struct command *impl_from_IConvertType( IConvertType *iface )
 449 {
 450     return CONTAINING_RECORD( iface, struct command, IConvertType_iface );
 451 }
 452
 453 static inline struct command *impl_from_ICommandPrepare( ICommandPrepare *iface )
 454 {
 455     return CONTAINING_RECORD( iface, struct command, ICommandPrepare_iface );
 456 }
 457
 458 static inline struct command *impl_from_ICommandWithParameters( ICommandWithParameters *iface )
 459 {
 460     return CONTAINING_RECORD( iface, struct command, ICommandWithParameters_iface );
 461 }
 462
 463 static HRESULT WINAPI command_QueryInterface(ICommandText *iface, REFIID riid, void **ppv)
 464 {
 465     struct command *command = impl_from_ICommandText( iface );
 466
 467     TRACE( "%p, %s, %p\n", command, debugstr_guid(riid), ppv );
 468     *ppv = NULL;
 469
 470     if(IsEqualGUID(&IID_IUnknown, riid) ||
 471        IsEqualGUID(&IID_ICommand, riid) ||
 472        IsEqualGUID(&IID_ICommandText, riid))
 473     {
 474         *ppv = &command->ICommandText_iface;
 475     }
 476     else if(IsEqualGUID(&IID_ICommandProperties, riid))
 477     {
 478          *ppv = &command->ICommandProperties_iface;
 479     }
 480     else if(IsEqualGUID(&IID_IColumnsInfo, riid))
 481     {
 482          *ppv = &command->IColumnsInfo_iface;
 483     }
 484     else if(IsEqualGUID(&IID_IConvertType, riid))
 485     {
 486          *ppv = &command->IConvertType_iface;
 487     }
 488     else if(IsEqualGUID(&IID_ICommandPrepare, riid))
 489     {
 490          *ppv = &command->ICommandPrepare_iface;
 491     }
 492     else if(IsEqualGUID(&IID_ICommandWithParameters, riid))
 493     {
 494         *ppv = &command->ICommandWithParameters_iface;
 495     }
 496
 497     if(*ppv)
 498     {
 499         IUnknown_AddRef((IUnknown*)*ppv);
 500         return S_OK;
 501     }
 502     else if (IsEqualGUID(&IID_IMultipleResults, riid))
 503     {
 504         TRACE("IID_IMultipleResults not supported\n");
 505         return E_NOINTERFACE;
 506     }
 507     else if(IsEqualGUID(&IID_ICommandStream, riid))
 508     {
 509         TRACE("ICommandStream not support\n");
 510         return E_NOINTERFACE;
 511     }
 512     else if (IsEqualGUID(&IID_IRowsetChange, riid))
 513     {
 514         TRACE("IID_IRowsetChange not supported\n");
 515         return E_NOINTERFACE;
 516     }
 517     else if (IsEqualGUID(&IID_IRowsetUpdate, riid))
 518     {
 519         TRACE("IID_IRowsetUpdate not supported\n");
 520         return E_NOINTERFACE;
 521     }
 522     else if (IsEqualGUID(&IID_IRowsetLocate, riid))
 523     {
 524         TRACE("IID_IRowsetLocate not supported\n");
 525         return E_NOINTERFACE;
 526     }
 527
 528     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 529     return E_NOINTERFACE;
 530 }
 531
 532 static ULONG WINAPI command_AddRef(ICommandText *iface)
 533 {
 534     struct command *command = impl_from_ICommandText( iface );
 535     LONG refs = InterlockedIncrement( &command->refs );
 536     TRACE( "%p new refcount %ld\n", command, refs );
 537     return refs;
 538 }
 539
 540 static ULONG WINAPI command_Release(ICommandText *iface)
 541 {
 542     struct command *command = impl_from_ICommandText( iface );
 543     LONG refs = InterlockedDecrement( &command->refs );
 544     TRACE( "%p new refcount %ld\n", command, refs );
 545     if (!refs)
 546     {
 547         TRACE( "destroying %p\n", command );
 548         if (command->properties)
 549             heap_free(command->properties);
 550         if (command->session)
 551             IUnknown_Release(command->session);
 552
 553         if (command->hstmt)
 554             SQLFreeHandle(SQL_HANDLE_STMT, command->hstmt);
 555
 556         heap_free( command->query );
 557         heap_free( command );
 558     }
 559     return refs;
 560 }
 561
 562 static HRESULT WINAPI command_Cancel(ICommandText *iface)
 563 {
 564     struct command *command = impl_from_ICommandText( iface );
 565     FIXME("%p\n", command);
 566     return E_NOTIMPL;
 567 }
 568
 569 struct msdasql_rowset
 570 {
 571     IRowset IRowset_iface;
 572     IRowsetInfo IRowsetInfo_iface;
 573     IColumnsInfo IColumnsInfo_iface;
 574     IAccessor IAccessor_iface;
 575     IColumnsRowset IColumnsRowset_iface;
 576     IUnknown *caller;
 577     LONG refs;
 578     SQLHSTMT hstmt;
 579 };
 580
 581 static inline struct msdasql_rowset *impl_from_IRowset( IRowset *iface )
 582 {
 583     return CONTAINING_RECORD( iface, struct msdasql_rowset, IRowset_iface );
 584 }
 585
 586 static inline struct msdasql_rowset *impl_from_IRowsetInfo( IRowsetInfo *iface )
 587 {
 588     return CONTAINING_RECORD( iface, struct msdasql_rowset, IRowsetInfo_iface );
 589 }
 590
 591 static inline struct msdasql_rowset *rowset_impl_from_IColumnsInfo( IColumnsInfo *iface )
 592 {
 593     return CONTAINING_RECORD( iface, struct msdasql_rowset, IColumnsInfo_iface );
 594 }
 595
 596 static inline struct msdasql_rowset *impl_from_IAccessor ( IAccessor *iface )
 597 {
 598     return CONTAINING_RECORD( iface, struct msdasql_rowset, IAccessor_iface );
 599 }
 600
 601 static inline struct msdasql_rowset *impl_from_IColumnsRowset ( IColumnsRowset *iface )
 602 {
 603     return CONTAINING_RECORD( iface, struct msdasql_rowset, IColumnsRowset_iface );
 604 }
 605
 606 static HRESULT WINAPI msdasql_rowset_QueryInterface(IRowset *iface, REFIID riid,  void **ppv)
 607 {
 608     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 609
 610     TRACE( "%p, %s, %p\n", rowset, debugstr_guid(riid), ppv );
 611
 612     *ppv = NULL;
 613     if(IsEqualGUID(&IID_IUnknown, riid) ||
 614        IsEqualGUID(&IID_IRowset, riid))
 615     {
 616         *ppv = &rowset->IRowset_iface;
 617     }
 618     else if (IsEqualGUID(&IID_IRowsetInfo, riid))
 619     {
 620         *ppv = &rowset->IRowsetInfo_iface;
 621     }
 622     else if (IsEqualGUID(&IID_IColumnsInfo, riid))
 623     {
 624         *ppv = &rowset->IColumnsInfo_iface;
 625     }
 626     else if(IsEqualGUID(&IID_IAccessor, riid))
 627     {
 628          *ppv = &rowset->IAccessor_iface;
 629     }
 630     else if(IsEqualGUID(&IID_IColumnsRowset, riid))
 631     {
 632          *ppv = &rowset->IColumnsRowset_iface;
 633     }
 634     else if (IsEqualGUID(&IID_IRowsetChange, riid))
 635     {
 636         TRACE("IID_IRowsetChange not supported\n");
 637         return E_NOINTERFACE;
 638     }
 639     else if (IsEqualGUID(&IID_IRowsetUpdate, riid))
 640     {
 641         TRACE("IID_IRowsetUpdate not supported\n");
 642         return E_NOINTERFACE;
 643     }
 644     else if (IsEqualGUID(&IID_IRowsetLocate, riid))
 645     {
 646         TRACE("IID_IRowsetLocate not supported\n");
 647         return E_NOINTERFACE;
 648     }
 649
 650     if(*ppv)
 651     {
 652         IUnknown_AddRef((IUnknown*)*ppv);
 653         return S_OK;
 654     }
 655
 656     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 657     return E_NOINTERFACE;
 658 }
 659
 660 static ULONG WINAPI msdasql_rowset_AddRef(IRowset *iface)
 661 {
 662     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 663     LONG refs = InterlockedIncrement( &rowset->refs );
 664     TRACE( "%p new refcount %ld\n", rowset, refs );
 665     return refs;
 666 }
 667
 668 static ULONG WINAPI msdasql_rowset_Release(IRowset *iface)
 669 {
 670     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 671     LONG refs = InterlockedDecrement( &rowset->refs );
 672     TRACE( "%p new refcount %ld\n", rowset, refs );
 673     if (!refs)
 674     {
 675         TRACE( "destroying %p\n", rowset );
 676
 677         SQLFreeHandle(SQL_HANDLE_STMT, rowset->hstmt);
 678
 679         if (rowset->caller)
 680             IUnknown_Release(rowset->caller);
 681
 682         heap_free( rowset );
 683     }
 684     return refs;
 685 }
 686
 687 static HRESULT WINAPI msdasql_rowset_AddRefRows(IRowset *iface, DBCOUNTITEM count,
 688         const HROW rows[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
 689 {
 690     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 691     FIXME("%p, %Id, %p, %p, %p\n", rowset, count, rows, ref_counts, status);
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI msdasql_rowset_GetData(IRowset *iface, HROW row, HACCESSOR accessor, void *data)
 696 {
 697     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 698     FIXME("%p, %Id, %Id, %p\n", rowset, row, accessor, data);
 699     return E_NOTIMPL;
 700 }
 701
 702 static HRESULT WINAPI msdasql_rowset_GetNextRows(IRowset *iface, HCHAPTER reserved, DBROWOFFSET offset,
 703         DBROWCOUNT count, DBCOUNTITEM *obtained, HROW **rows)
 704 {
 705     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 706     FIXME("%p, %Id, %Id, %Id, %p, %p\n", rowset, reserved, offset, count, obtained, rows);
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI msdasql_rowset_ReleaseRows(IRowset *iface, DBCOUNTITEM count,
 711         const HROW rows[], DBROWOPTIONS options[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
 712 {
 713     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 714
 715     FIXME("%p, %Id, %p, %p, %p, %p\n", rowset, count, rows, options, ref_counts, status);
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI msdasql_rowset_RestartPosition(IRowset *iface, HCHAPTER reserved)
 720 {
 721     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 722     FIXME("%p, %Id\n", rowset, reserved);
 723     return E_NOTIMPL;
 724 }
 725
 726 static const struct IRowsetVtbl msdasql_rowset_vtbl =
 727 {
 728     msdasql_rowset_QueryInterface,
 729     msdasql_rowset_AddRef,
 730     msdasql_rowset_Release,
 731     msdasql_rowset_AddRefRows,
 732     msdasql_rowset_GetData,
 733     msdasql_rowset_GetNextRows,
 734     msdasql_rowset_ReleaseRows,
 735     msdasql_rowset_RestartPosition
 736 };
 737
 738 static HRESULT WINAPI rowset_info_QueryInterface(IRowsetInfo *iface, REFIID riid, void **ppv)
 739 {
 740     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 741     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, ppv);
 742 }
 743
 744 static ULONG WINAPI rowset_info_AddRef(IRowsetInfo *iface)
 745 {
 746     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 747     return IRowset_AddRef(&rowset->IRowset_iface);
 748 }
 749
 750 static ULONG WINAPI rowset_info_Release(IRowsetInfo *iface)
 751 {
 752     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 753     return IRowset_Release(&rowset->IRowset_iface);
 754 }
 755
 756 static HRESULT WINAPI rowset_info_GetProperties(IRowsetInfo *iface, const ULONG count,
 757         const DBPROPIDSET propertyidsets[], ULONG *out_count, DBPROPSET **propertysets)
 758 {
 759     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 760     FIXME("%p, %lu, %p, %p, %p\n", rowset, count, propertyidsets, out_count, propertysets);
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI rowset_info_GetReferencedRowset(IRowsetInfo *iface, DBORDINAL ordinal,
 765         REFIID riid, IUnknown **unk)
 766 {
 767     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 768     FIXME("%p, %Id, %s, %p\n", rowset, ordinal, debugstr_guid(riid), unk);
 769     return E_NOTIMPL;
 770 }
 771
 772 static HRESULT WINAPI rowset_info_GetSpecification(IRowsetInfo *iface, REFIID riid,
 773         IUnknown **specification)
 774 {
 775     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 776
 777     TRACE("%p, %s, %p\n", rowset, debugstr_guid(riid), specification);
 778
 779     if (!specification)
 780         return E_INVALIDARG;
 781
 782     if (!rowset->caller)
 783         return S_FALSE;
 784
 785     return IUnknown_QueryInterface(rowset->caller, riid, (void**)specification);
 786 }
 787
 788 struct IRowsetInfoVtbl rowset_info_vtbl =
 789 {
 790     rowset_info_QueryInterface,
 791     rowset_info_AddRef,
 792     rowset_info_Release,
 793     rowset_info_GetProperties,
 794     rowset_info_GetReferencedRowset,
 795     rowset_info_GetSpecification
 796 };
 797
 798 static HRESULT WINAPI rowset_colsinfo_QueryInterface(IColumnsInfo *iface, REFIID riid, void **out)
 799 {
 800     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 801     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
 802 }
 803
 804 static ULONG WINAPI rowset_colsinfo_AddRef(IColumnsInfo *iface)
 805 {
 806     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 807     return IRowset_AddRef(&rowset->IRowset_iface);
 808 }
 809
 810 static ULONG  WINAPI rowset_colsinfo_Release(IColumnsInfo *iface)
 811 {
 812     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 813     return IRowset_Release(&rowset->IRowset_iface);
 814 }
 815
 816 static HRESULT WINAPI rowset_colsinfo_GetColumnInfo(IColumnsInfo *iface, DBORDINAL *columns,
 817         DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
 818 {
 819     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 820     FIXME("%p, %p, %p, %p\n", rowset, columns, colinfo, stringsbuffer);
 821     return E_NOTIMPL;
 822 }
 823
 824 static HRESULT WINAPI rowset_colsinfo_MapColumnIDs(IColumnsInfo *iface, DBORDINAL column_ids,
 825         const DBID *dbids, DBORDINAL *columns)
 826 {
 827     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 828     FIXME("%p, %Id, %p, %p\n", rowset, column_ids, dbids, columns);
 829     return E_NOTIMPL;
 830 }
 831
 832 static struct IColumnsInfoVtbl rowset_columninfo_vtbll =
 833 {
 834     rowset_colsinfo_QueryInterface,
 835     rowset_colsinfo_AddRef,
 836     rowset_colsinfo_Release,
 837     rowset_colsinfo_GetColumnInfo,
 838     rowset_colsinfo_MapColumnIDs
 839 };
 840
 841 static HRESULT WINAPI rowset_accessor_QueryInterface(IAccessor *iface, REFIID riid, void **out)
 842 {
 843     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
 844     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
 845 }
 846
 847 static ULONG WINAPI rowset_accessor_AddRef(IAccessor *iface)
 848 {
 849     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
 850     return IRowset_AddRef(&rowset->IRowset_iface);
 851 }
 852
 853 static ULONG  WINAPI rowset_accessor_Release(IAccessor *iface)
 854 {
 855     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
 856     return IRowset_Release(&rowset->IRowset_iface);
 857 }
 858
 859 static HRESULT WINAPI rowset_accessor_AddRefAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
 860 {
 861     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
 862     FIXME("%p, %Id, %p\n", rowset, accessor, count);
 863     return E_NOTIMPL;
 864 }
 865
 866 static HRESULT WINAPI rowset_accessor_CreateAccessor(IAccessor *iface, DBACCESSORFLAGS flags,
 867         DBCOUNTITEM count, const DBBINDING bindings[], DBLENGTH row_size, HACCESSOR *accessor,
 868         DBBINDSTATUS status[])
 869 {
 870     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
 871     FIXME("%p, 0x%08lx, %Id, %p, %Id, %p, %p\n", rowset, flags, count, bindings, row_size, accessor, status);
 872     return E_NOTIMPL;
 873 }
 874
 875 static HRESULT WINAPI rowset_accessor_GetBindings(IAccessor *iface, HACCESSOR accessor,
 876         DBACCESSORFLAGS *flags, DBCOUNTITEM *count, DBBINDING **bindings)
 877 {
 878     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
 879     FIXME("%p, %Id, %p, %p, %p\n", rowset, accessor, flags, count, bindings);
 880     return E_NOTIMPL;
 881 }
 882
 883 static HRESULT WINAPI rowset_accessor_ReleaseAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
 884 {
 885     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
 886     FIXME("%p, %Id, %p\n", rowset, accessor, count);
 887     return E_NOTIMPL;
 888 }
 889
 890 struct IAccessorVtbl accessor_vtbl =
 891 {
 892     rowset_accessor_QueryInterface,
 893     rowset_accessor_AddRef,
 894     rowset_accessor_Release,
 895     rowset_accessor_AddRefAccessor,
 896     rowset_accessor_CreateAccessor,
 897     rowset_accessor_GetBindings,
 898     rowset_accessor_ReleaseAccessor
 899 };
 900
 901 static HRESULT WINAPI column_rs_QueryInterface(IColumnsRowset *iface, REFIID riid, void **out)
 902 {
 903     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
 904     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
 905 }
 906
 907 static ULONG WINAPI column_rs_AddRef(IColumnsRowset *iface)
 908 {
 909     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
 910     return IRowset_AddRef(&rowset->IRowset_iface);
 911 }
 912
 913 static ULONG WINAPI column_rs_Release(IColumnsRowset *iface)
 914 {
 915     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
 916     return IRowset_Release(&rowset->IRowset_iface);
 917 }
 918
 919 static HRESULT WINAPI column_rs_GetAvailableColumns(IColumnsRowset *iface, DBORDINAL *count, DBID **columns)
 920 {
 921     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
 922     FIXME("%p, %p, %p\n", rowset, count, columns);
 923     return E_NOTIMPL;
 924 }
 925
 926 static HRESULT WINAPI column_rs_GetColumnsRowset(IColumnsRowset *iface, IUnknown *outer, DBORDINAL count,
 927         const DBID columns[], REFIID riid, ULONG property_cnt, DBPROPSET property_sets[], IUnknown **unk_rs)
 928 {
 929     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
 930     FIXME("(%p)->(%p, %Id, %p, %s, %lu, %p, %p): stub\n", rowset, outer, count, columns, debugstr_guid(riid),
 931           property_cnt, property_sets, unk_rs);
 932     return E_NOTIMPL;
 933 }
 934
 935 struct IColumnsRowsetVtbl columnrs_rs_vtbl =
 936 {
 937     column_rs_QueryInterface,
 938     column_rs_AddRef,
 939     column_rs_Release,
 940     column_rs_GetAvailableColumns,
 941     column_rs_GetColumnsRowset
 942 };
 943
 944 static HRESULT WINAPI command_Execute(ICommandText *iface, IUnknown *outer, REFIID riid,
 945         DBPARAMS *params, DBROWCOUNT *affected, IUnknown **rowset)
 946 {
 947     struct command *command = impl_from_ICommandText( iface );
 948     struct msdasql_rowset *msrowset;
 949     HRESULT hr = S_OK;
 950     RETCODE ret;
 951     SQLHSTMT hstmt = command->hstmt;
 952     SQLLEN results = -1;
 953
 954     TRACE("%p, %p, %s, %p %p %p\n", command, outer, debugstr_guid(riid), params, affected, rowset);
 955
 956     if (!hstmt)
 957         SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &hstmt);
 958
 959     ret = SQLExecDirectW(hstmt, command->query, SQL_NTS);
 960     if (ret != SQL_SUCCESS)
 961     {
 962         dump_sql_diag_records(SQL_HANDLE_STMT, hstmt);
 963         return E_FAIL;
 964     }
 965
 966     ret = SQLRowCount(hstmt, &results);
 967     if (ret != SQL_SUCCESS)
 968         ERR("SQLRowCount failed (%d)\n", ret);
 969
 970     if (affected)
 971         *affected = results;
 972
 973     *rowset = NULL;
 974     if (!wcsnicmp( command->query, L"select ", 7 ))
 975     {
 976         msrowset = heap_alloc(sizeof(*msrowset));
 977         if (!msrowset)
 978             return E_OUTOFMEMORY;
 979
 980         command->hstmt = NULL;
 981
 982         msrowset->IRowset_iface.lpVtbl = &msdasql_rowset_vtbl;
 983         msrowset->IRowsetInfo_iface.lpVtbl = &rowset_info_vtbl;
 984         msrowset->IColumnsInfo_iface.lpVtbl = &rowset_columninfo_vtbll;
 985         msrowset->IAccessor_iface.lpVtbl = &accessor_vtbl;
 986         msrowset->IColumnsRowset_iface.lpVtbl = &columnrs_rs_vtbl;
 987         msrowset->refs = 1;
 988         ICommandText_QueryInterface(iface, &IID_IUnknown, (void**)&msrowset->caller);
 989         msrowset->hstmt = hstmt;
 990
 991         hr = IRowset_QueryInterface(&msrowset->IRowset_iface, riid, (void**)rowset);
 992         IRowset_Release(&msrowset->IRowset_iface);
 993     }
 994     else
 995         SQLFreeStmt(hstmt, SQL_CLOSE);
 996
 997     return hr;
 998 }
 999
1000 static HRESULT WINAPI command_GetDBSession(ICommandText *iface, REFIID riid, IUnknown **session)
1001 {
1002     struct command *command = impl_from_ICommandText( iface );
1003
1004     TRACE("%p, %s, %p\n", command, debugstr_guid(riid), session);
1005
1006     if (!session)
1007         return E_INVALIDARG;
1008
1009     *session = NULL;
1010
1011     if (!command->session)
1012         return S_FALSE;
1013
1014     return IUnknown_QueryInterface(command->session, riid, (void**)session);
1015 }
1016
1017 static HRESULT WINAPI command_GetCommandText(ICommandText *iface, GUID *dialect, LPOLESTR *commandstr)
1018 {
1019     struct command *command = impl_from_ICommandText( iface );
1020     HRESULT hr = S_OK;
1021     TRACE("%p, %p, %p\n", command, dialect, commandstr);
1022
1023     if (!command->query)
1024         return DB_E_NOCOMMAND;
1025
1026     if (dialect && !IsEqualGUID(&DBGUID_DEFAULT, dialect))
1027     {
1028         *dialect = DBGUID_DEFAULT;
1029         hr = DB_S_DIALECTIGNORED;
1030     }
1031
1032     *commandstr = heap_alloc((lstrlenW(command->query)+1)*sizeof(WCHAR));
1033     wcscpy(*commandstr, command->query);
1034     return hr;
1035 }
1036
1037 static HRESULT WINAPI command_SetCommandText(ICommandText *iface, REFGUID dialect, LPCOLESTR commandstr)
1038 {
1039     struct command *command = impl_from_ICommandText( iface );
1040     TRACE("%p, %s, %s\n", command, debugstr_guid(dialect), debugstr_w(commandstr));
1041
1042     if (!IsEqualGUID(&DBGUID_DEFAULT, dialect))
1043         FIXME("Currently non Default Dialect isn't supported\n");
1044
1045     heap_free(command->query);
1046
1047     if (commandstr)
1048     {
1049         command->query = heap_alloc((lstrlenW(commandstr)+1)*sizeof(WCHAR));
1050         if (!command->query)
1051             return E_OUTOFMEMORY;
1052
1053         wcscpy(command->query, commandstr);
1054     }
1055     else
1056         command->query = NULL;
1057     return S_OK;
1058 }
1059
1060 static const ICommandTextVtbl commandVtbl =
1061 {
1062     command_QueryInterface,
1063     command_AddRef,
1064     command_Release,
1065     command_Cancel,
1066     command_Execute,
1067     command_GetDBSession,
1068     command_GetCommandText,
1069     command_SetCommandText
1070 };
1071
1072 static HRESULT WINAPI command_prop_QueryInterface(ICommandProperties *iface, REFIID riid, void **out)
1073 {
1074     struct command *command = impl_from_ICommandProperties( iface );
1075     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1076 }
1077
1078 static ULONG WINAPI command_prop_AddRef(ICommandProperties *iface)
1079 {
1080     struct command *command = impl_from_ICommandProperties( iface );
1081     return ICommandText_AddRef(&command->ICommandText_iface);
1082 }
1083
1084 static ULONG WINAPI command_prop_Release(ICommandProperties *iface)
1085 {
1086     struct command *command = impl_from_ICommandProperties( iface );
1087     return ICommandText_Release(&command->ICommandText_iface);
1088 }
1089
1090 static ULONG get_property_count(DWORD flag, struct msdasql_prop *properties, int prop_count)
1091 {
1092     int i, count = 0;
1093
1094     for(i=0; i < prop_count; i++)
1095     {
1096         if (properties[i].flags & flag)
1097             count++;
1098     }
1099
1100     return count;
1101 }
1102
1103 static HRESULT WINAPI command_prop_GetProperties(ICommandProperties *iface, ULONG count,
1104         const DBPROPIDSET propertyidsets[], ULONG *sets_cnt, DBPROPSET **propertyset)
1105 {
1106     struct command *command = impl_from_ICommandProperties( iface );
1107     DBPROPSET *propset = NULL;
1108     int i, j, k;
1109
1110     TRACE("%p %ld %p %p %p\n", command, count, propertyidsets, sets_cnt, propertyset);
1111
1112     /* All Properties */
1113     if (count == 0)
1114     {
1115         int idx;
1116         propset = CoTaskMemAlloc(2 * sizeof(DBPROPSET));
1117         if (!propset)
1118             return E_OUTOFMEMORY;
1119
1120         propset[0].guidPropertySet = DBPROPSET_ROWSET;
1121         propset[0].cProperties = get_property_count(DBPROPFLAGS_ROWSET, command->properties, command->prop_count);
1122         propset[0].rgProperties = CoTaskMemAlloc(propset[0].cProperties * sizeof(DBPROP));
1123         if (!propset[0].rgProperties)
1124         {
1125             CoTaskMemFree(propset);
1126             return E_OUTOFMEMORY;
1127         }
1128
1129         idx = 0;
1130         for (j=0; j < command->prop_count; j++)
1131         {
1132             if (!(command->properties[j].flags & DBPROPFLAGS_ROWSET))
1133                 continue;
1134             propset[0].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1135
1136             V_VT(&propset[0].rgProperties[idx].vValue) = command->properties[j].vartype;
1137             if (command->properties[j].vartype == VT_BOOL)
1138             {
1139                 V_BOOL(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1140             }
1141             else if (command->properties[j].vartype == VT_I4)
1142             {
1143                 V_I4(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1144             }
1145             else
1146                 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1147
1148             idx++;
1149         }
1150
1151         propset[1].guidPropertySet = DBPROPSET_PROVIDERROWSET;
1152         propset[1].cProperties = get_property_count(DBPROPFLAGS_DATASOURCEINFO, command->properties, command->prop_count);
1153         propset[1].rgProperties = CoTaskMemAlloc(propset[1].cProperties * sizeof(DBPROP));
1154         if (!propset[1].rgProperties)
1155         {
1156             CoTaskMemFree(propset[0].rgProperties);
1157             CoTaskMemFree(propset);
1158             return E_OUTOFMEMORY;
1159         }
1160
1161         idx = 0;
1162         for (j=0; j < command->prop_count; j++)
1163         {
1164             if (!(command->properties[j].flags & DBPROPFLAGS_DATASOURCEINFO))
1165                 continue;
1166             propset[1].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1167
1168             V_VT(&propset[1].rgProperties[idx].vValue) = command->properties[j].vartype;
1169             if (command->properties[j].vartype == VT_BOOL)
1170             {
1171                 V_BOOL(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1172             }
1173             else if (command->properties[j].vartype == VT_I4)
1174             {
1175                 V_I4(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1176             }
1177             else
1178                 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1179
1180             idx++;
1181         }
1182
1183         *sets_cnt = 2;
1184     }
1185     else
1186     {
1187         propset = CoTaskMemAlloc(count * sizeof(DBPROPSET));
1188         if (!propset)
1189             return E_OUTOFMEMORY;
1190
1191         for (i=0; i < count; i++)
1192         {
1193             TRACE("Property id %d (count %ld, set %s)\n", i, propertyidsets[i].cPropertyIDs,
1194                     debugstr_guid(&propertyidsets[i].guidPropertySet));
1195
1196             propset[i].cProperties = propertyidsets[i].cPropertyIDs;
1197             propset[i].rgProperties = CoTaskMemAlloc(propset[i].cProperties * sizeof(DBPROP));
1198
1199             for (j=0; j < propset[i].cProperties; j++)
1200             {
1201                 propset[i].rgProperties[j].dwPropertyID = propertyidsets[i].rgPropertyIDs[j];
1202
1203                 for(k = 0; k < command->prop_count; k++)
1204                 {
1205                     if (command->properties[k].property_id == propertyidsets[i].rgPropertyIDs[j])
1206                     {
1207                         V_VT(&propset[i].rgProperties[i].vValue) = command->properties[j].vartype;
1208                         if (command->properties[j].vartype == VT_BOOL)
1209                         {
1210                             V_BOOL(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1211                         }
1212                         else if (command->properties[j].vartype == VT_I4)
1213                         {
1214                             V_I4(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1215                         }
1216                         else
1217                             ERR("Unknown variant type %d\n", command->properties[j].vartype);
1218                         break;
1219                     }
1220                 }
1221             }
1222         }
1223
1224         *sets_cnt = count;
1225     }
1226
1227     *propertyset = propset;
1228
1229     return S_OK;
1230 }
1231
1232 static HRESULT WINAPI command_prop_SetProperties(ICommandProperties *iface, ULONG count,
1233         DBPROPSET propertyset[])
1234 {
1235     struct command *command = impl_from_ICommandProperties( iface );
1236     int i, j, k;
1237
1238     TRACE("%p %lu, %p\n", command, count, propertyset);
1239
1240     for(i=0; i < count; i++)
1241     {
1242         TRACE("set %s, count %ld\n", debugstr_guid(&propertyset[i].guidPropertySet), propertyset[i].cProperties);
1243         for(j=0; j < propertyset[i].cProperties; j++)
1244         {
1245             for(k=0; k < command->prop_count; k++)
1246             {
1247                 if (command->properties[k].property_id == propertyset[i].rgProperties[j].dwPropertyID)
1248                 {
1249                     TRACE("Found property 0x%08lx\n", command->properties[k].property_id);
1250                     if (command->properties[k].flags & DBPROPFLAGS_WRITE)
1251                     {
1252                         if (command->properties[k].vartype == VT_BOOL)
1253                         {
1254                             command->properties[k].value = V_BOOL(&propertyset[i].rgProperties[j].vValue);
1255                         }
1256                         else if (command->properties[k].vartype == VT_I4)
1257                         {
1258                             command->properties[k].value = V_I4(&propertyset[i].rgProperties[j].vValue);
1259                         }
1260                         else
1261                             ERR("Unknown variant type %d\n", command->properties[j].vartype);
1262                     }
1263                     else
1264                         WARN("Attempting to set Readonly property\n");
1265
1266                     break;
1267                 }
1268             }
1269         }
1270     }
1271     return S_OK;
1272 }
1273
1274 static const ICommandPropertiesVtbl commonpropsVtbl =
1275 {
1276     command_prop_QueryInterface,
1277     command_prop_AddRef,
1278     command_prop_Release,
1279     command_prop_GetProperties,
1280     command_prop_SetProperties
1281 };
1282
1283 static HRESULT WINAPI colsinfo_QueryInterface(IColumnsInfo *iface, REFIID riid, void **out)
1284 {
1285     struct command *command = impl_from_IColumnsInfo( iface );
1286     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1287 }
1288
1289 static ULONG WINAPI colsinfo_AddRef(IColumnsInfo *iface)
1290 {
1291     struct command *command = impl_from_IColumnsInfo( iface );
1292     return ICommandText_AddRef(&command->ICommandText_iface);
1293 }
1294
1295 static ULONG  WINAPI colsinfo_Release(IColumnsInfo *iface)
1296 {
1297     struct command *command = impl_from_IColumnsInfo( iface );
1298     return ICommandText_Release(&command->ICommandText_iface);
1299 }
1300
1301 static HRESULT WINAPI colsinfo_GetColumnInfo(IColumnsInfo *iface, DBORDINAL *columns,
1302         DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
1303 {
1304     struct command *command = impl_from_IColumnsInfo( iface );
1305     FIXME("%p, %p, %p, %p\n", command, columns, colinfo, stringsbuffer);
1306     return E_NOTIMPL;
1307 }
1308
1309 static HRESULT WINAPI colsinfo_MapColumnIDs(IColumnsInfo *iface, DBORDINAL column_ids,
1310         const DBID *dbids, DBORDINAL *columns)
1311 {
1312     struct command *command = impl_from_IColumnsInfo( iface );
1313     FIXME("%p, %Iu, %p, %p\n", command, column_ids, dbids, columns);
1314     return E_NOTIMPL;
1315 }
1316
1317 static struct IColumnsInfoVtbl columninfoVtbl =
1318 {
1319     colsinfo_QueryInterface,
1320     colsinfo_AddRef,
1321     colsinfo_Release,
1322     colsinfo_GetColumnInfo,
1323     colsinfo_MapColumnIDs
1324 };
1325
1326 static HRESULT WINAPI converttype_QueryInterface(IConvertType *iface, REFIID riid, void **out)
1327 {
1328     struct command *command = impl_from_IConvertType( iface );
1329     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1330 }
1331
1332 static ULONG WINAPI converttype_AddRef(IConvertType *iface)
1333 {
1334     struct command *command = impl_from_IConvertType( iface );
1335     return ICommandText_AddRef(&command->ICommandText_iface);
1336 }
1337
1338 static ULONG WINAPI converttype_Release(IConvertType *iface)
1339 {
1340     struct command *command = impl_from_IConvertType( iface );
1341     return ICommandText_Release(&command->ICommandText_iface);
1342 }
1343
1344 static HRESULT WINAPI converttype_CanConvert(IConvertType *iface, DBTYPE from, DBTYPE to, DBCONVERTFLAGS flags)
1345 {
1346     struct command *command = impl_from_IConvertType( iface );
1347     FIXME("%p, %u, %d, 0x%08lx\n", command, from, to, flags);
1348     return E_NOTIMPL;
1349 }
1350
1351 static struct IConvertTypeVtbl converttypeVtbl =
1352 {
1353     converttype_QueryInterface,
1354     converttype_AddRef,
1355     converttype_Release,
1356     converttype_CanConvert
1357 };
1358
1359 static HRESULT WINAPI commandprepare_QueryInterface(ICommandPrepare *iface, REFIID riid, void **out)
1360 {
1361     struct command *command = impl_from_ICommandPrepare( iface );
1362     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1363 }
1364
1365 static ULONG WINAPI commandprepare_AddRef(ICommandPrepare *iface)
1366 {
1367     struct command *command = impl_from_ICommandPrepare( iface );
1368     return ICommandText_AddRef(&command->ICommandText_iface);
1369 }
1370
1371 static ULONG WINAPI commandprepare_Release(ICommandPrepare *iface)
1372 {
1373     struct command *command = impl_from_ICommandPrepare( iface );
1374     return ICommandText_Release(&command->ICommandText_iface);
1375 }
1376
1377 static HRESULT WINAPI commandprepare_Prepare(ICommandPrepare *iface, ULONG runs)
1378 {
1379     struct command *command = impl_from_ICommandPrepare( iface );
1380     RETCODE ret;
1381
1382     TRACE("%p, %lu\n", command, runs);
1383
1384     if (!command->query)
1385         return DB_E_NOCOMMAND;
1386
1387     if (command->hstmt)
1388         SQLFreeHandle(SQL_HANDLE_STMT, command->hstmt);
1389
1390     SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &command->hstmt);
1391
1392     ret = SQLPrepareW(command->hstmt, command->query, SQL_NTS);
1393     if (ret != SQL_SUCCESS)
1394     {
1395         dump_sql_diag_records(SQL_HANDLE_STMT, command->hstmt);
1396         return E_FAIL;
1397     }
1398     return S_OK;
1399 }
1400
1401 static HRESULT WINAPI commandprepare_Unprepare(ICommandPrepare *iface)
1402 {
1403     struct command *command = impl_from_ICommandPrepare( iface );
1404     TRACE("%p\n", command);
1405     return S_OK;
1406 }
1407
1408 struct ICommandPrepareVtbl commandprepareVtbl =
1409 {
1410     commandprepare_QueryInterface,
1411     commandprepare_AddRef,
1412     commandprepare_Release,
1413     commandprepare_Prepare,
1414     commandprepare_Unprepare
1415 };
1416
1417 static HRESULT WINAPI cmd_with_params_QueryInterface(ICommandWithParameters *iface, REFIID riid, void **out)
1418 {
1419     struct command *command = impl_from_ICommandWithParameters( iface );
1420     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1421 }
1422
1423 static ULONG WINAPI cmd_with_params_AddRef(ICommandWithParameters *iface)
1424 {
1425     struct command *command = impl_from_ICommandWithParameters( iface );
1426     return ICommandText_AddRef(&command->ICommandText_iface);
1427 }
1428
1429 static ULONG WINAPI cmd_with_params_Release(ICommandWithParameters *iface)
1430 {
1431     struct command *command = impl_from_ICommandWithParameters( iface );
1432     return ICommandText_Release(&command->ICommandText_iface);
1433 }
1434
1435 static HRESULT WINAPI cmd_with_params_GetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS *uparams,
1436         DBPARAMINFO **info, OLECHAR **buffer)
1437 {
1438     struct command *command = impl_from_ICommandWithParameters( iface );
1439     FIXME("%p, %p, %p, %p\n", command, uparams, info, buffer);
1440     return E_NOTIMPL;
1441 }
1442
1443 static HRESULT WINAPI cmd_with_params_MapParameterNames(ICommandWithParameters *iface, DB_UPARAMS uparams,
1444         LPCWSTR names[], DB_LPARAMS ordinals[])
1445 {
1446     struct command *command = impl_from_ICommandWithParameters( iface );
1447     FIXME("%p, %Iu, %p, %p\n", command, uparams, names, ordinals);
1448     return E_NOTIMPL;
1449 }
1450
1451 static HRESULT WINAPI cmd_with_params_SetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS uparams,
1452         const DB_UPARAMS ordinals[], const DBPARAMBINDINFO bindinfo[])
1453 {
1454     struct command *command = impl_from_ICommandWithParameters( iface );
1455     FIXME("%p, %Iu, %p, %p\n", command, uparams, ordinals, bindinfo);
1456     return E_NOTIMPL;
1457 }
1458
1459 struct ICommandWithParametersVtbl command_with_params_vtbl =
1460 {
1461     cmd_with_params_QueryInterface,
1462     cmd_with_params_AddRef,
1463     cmd_with_params_Release,
1464     cmd_with_params_GetParameterInfo,
1465     cmd_with_params_MapParameterNames,
1466     cmd_with_params_SetParameterInfo
1467 };
1468
1469 static HRESULT WINAPI createcommand_CreateCommand(IDBCreateCommand *iface, IUnknown *outer, REFIID riid,
1470                                             IUnknown **out)
1471 {
1472     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
1473     struct command *command;
1474     HRESULT hr;
1475
1476     TRACE("%p, %p, %s, %p\n", session, outer, debugstr_guid(riid), out);
1477
1478     if (outer)
1479         FIXME("Outer not currently supported\n");
1480
1481     command = heap_alloc(sizeof(*command));
1482     if (!command)
1483         return E_OUTOFMEMORY;
1484
1485     command->ICommandText_iface.lpVtbl = &commandVtbl;
1486     command->ICommandProperties_iface.lpVtbl = &commonpropsVtbl;
1487     command->IColumnsInfo_iface.lpVtbl = &columninfoVtbl;
1488     command->IConvertType_iface.lpVtbl = &converttypeVtbl;
1489     command->ICommandPrepare_iface.lpVtbl = &commandprepareVtbl;
1490     command->ICommandWithParameters_iface.lpVtbl = &command_with_params_vtbl;
1491     command->refs = 1;
1492     command->query = NULL;
1493     command->hdbc = session->hdbc;
1494     command->hstmt = NULL;
1495
1496     command->prop_count = ARRAY_SIZE(msdasql_init_props);
1497     command->properties = heap_alloc(sizeof(msdasql_init_props));
1498     memcpy(command->properties, msdasql_init_props, sizeof(msdasql_init_props));
1499
1500     IUnknown_QueryInterface(&session->session_iface, &IID_IUnknown, (void**)&command->session);
1501
1502     hr = ICommandText_QueryInterface(&command->ICommandText_iface, riid, (void**)out);
1503     ICommandText_Release(&command->ICommandText_iface);
1504     return hr;
1505 }
1506
1507 static const IDBCreateCommandVtbl createcommandVtbl =
1508 {
1509     createcommand_QueryInterface,
1510     createcommand_AddRef,
1511     createcommand_Release,
1512     createcommand_CreateCommand
1513 };
1514
1515 static HRESULT WINAPI transjoin_QueryInterface(ITransactionJoin *iface, REFIID riid, void **out)
1516 {
1517     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1518     return IUnknown_QueryInterface(&session->session_iface, riid, out);
1519 }
1520
1521 static ULONG WINAPI transjoin_AddRef(ITransactionJoin *iface)
1522 {
1523     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1524     return IUnknown_AddRef(&session->session_iface);
1525 }
1526
1527 static ULONG WINAPI transjoin_Release(ITransactionJoin *iface)
1528 {
1529     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1530     return IUnknown_Release(&session->session_iface);
1531 }
1532
1533 static HRESULT WINAPI transjoin_GetOptionsObject(ITransactionJoin *iface, ITransactionOptions **options)
1534 {
1535     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1536
1537     FIXME("%p, %p\n", session, options);
1538
1539     return E_NOTIMPL;
1540 }
1541
1542 static HRESULT WINAPI transjoin_JoinTransaction(ITransactionJoin *iface, IUnknown *unk, ISOLEVEL level,
1543     ULONG flags, ITransactionOptions *options)
1544 {
1545     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1546
1547     FIXME("%p, %p, %lu, 0x%08lx, %p\n", session, unk, level, flags, options);
1548
1549     return E_NOTIMPL;
1550 }
1551
1552 static const ITransactionJoinVtbl transactionjoinVtbl =
1553 {
1554     transjoin_QueryInterface,
1555     transjoin_AddRef,
1556     transjoin_Release,
1557     transjoin_GetOptionsObject,
1558     transjoin_JoinTransaction
1559 };
1560
1561 static HRESULT WINAPI transaction_QueryInterface(ITransaction *iface, REFIID riid, void **out)
1562 {
1563     struct msdasql_session *session = impl_from_ITransaction( iface );
1564     return IUnknown_QueryInterface(&session->session_iface, riid, out);
1565 }
1566
1567 static ULONG WINAPI transaction_AddRef(ITransaction *iface)
1568 {
1569     struct msdasql_session *session = impl_from_ITransaction( iface );
1570     return IUnknown_AddRef(&session->session_iface);
1571 }
1572
1573 static ULONG WINAPI transaction_Release(ITransaction *iface)
1574 {
1575     struct msdasql_session *session = impl_from_ITransaction( iface );
1576     return IUnknown_Release(&session->session_iface);
1577 }
1578
1579 static HRESULT WINAPI transaction_Commit(ITransaction *iface, BOOL retaining, DWORD tc, DWORD rm)
1580 {
1581     struct msdasql_session *session = impl_from_ITransaction( iface );
1582
1583     FIXME("%p, %d, %ld, %ld\n", session, retaining, tc, rm);
1584
1585     return E_NOTIMPL;
1586 }
1587
1588 static HRESULT WINAPI transaction_Abort(ITransaction *iface, BOID *reason, BOOL retaining, BOOL async)
1589 {
1590     struct msdasql_session *session = impl_from_ITransaction( iface );
1591
1592     FIXME("%p, %p, %d, %d\n", session, reason, retaining, async);
1593
1594     return E_NOTIMPL;
1595 }
1596
1597 static HRESULT WINAPI transaction_GetTransactionInfo(ITransaction *iface, XACTTRANSINFO *info)
1598 {
1599     struct msdasql_session *session = impl_from_ITransaction( iface );
1600
1601     FIXME("%p, %p\n", session, info);
1602
1603     return E_NOTIMPL;
1604 }
1605
1606 static const ITransactionVtbl transactionVtbl =
1607 {
1608     transaction_QueryInterface,
1609     transaction_AddRef,
1610     transaction_Release,
1611     transaction_Commit,
1612     transaction_Abort,
1613     transaction_GetTransactionInfo
1614 };
1615
1616 HRESULT create_db_session(REFIID riid, IUnknown *datasource, HDBC hdbc, void **unk)
1617 {
1618     struct msdasql_session *session;
1619     HRESULT hr;
1620
1621     session = heap_alloc(sizeof(*session));
1622     if (!session)
1623         return E_OUTOFMEMORY;
1624
1625     session->session_iface.lpVtbl = &unkfactoryVtbl;
1626     session->IGetDataSource_iface.lpVtbl = &datasourceVtbl;
1627     session->IOpenRowset_iface.lpVtbl = &openrowsetVtbl;
1628     session->ISessionProperties_iface.lpVtbl = &propertiesVtbl;
1629     session->IDBCreateCommand_iface.lpVtbl = &createcommandVtbl;
1630     session->ITransactionJoin_iface.lpVtbl = &transactionjoinVtbl;
1631     session->ITransaction_iface.lpVtbl = &transactionVtbl;
1632
1633     IUnknown_QueryInterface(datasource, &IID_IUnknown, (void**)&session->datasource);
1634     session->refs = 1;
1635     session->hdbc = hdbc;
1636
1637     hr = IUnknown_QueryInterface(&session->session_iface, riid, unk);
1638     IUnknown_Release(&session->session_iface);
1639     return hr;
1640 }