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 #define SQLTYPE_TO_STR(x) case x: return #x
 133
 134 static const char *debugstr_sqltype(SQLSMALLINT type)
 135 {
 136     switch (type)
 137     {
 138         SQLTYPE_TO_STR(SQL_DECIMAL);
 139         SQLTYPE_TO_STR(SQL_CHAR);
 140         SQLTYPE_TO_STR(SQL_VARCHAR);
 141         SQLTYPE_TO_STR(SQL_LONGVARCHAR);
 142         SQLTYPE_TO_STR(SQL_NUMERIC);
 143         SQLTYPE_TO_STR(SQL_GUID);
 144         SQLTYPE_TO_STR(SQL_TINYINT);
 145         SQLTYPE_TO_STR(SQL_SMALLINT);
 146         SQLTYPE_TO_STR(SQL_INTEGER);
 147         SQLTYPE_TO_STR(SQL_REAL);
 148         SQLTYPE_TO_STR(SQL_FLOAT);
 149         SQLTYPE_TO_STR(SQL_DOUBLE);
 150         SQLTYPE_TO_STR(SQL_BINARY);
 151         SQLTYPE_TO_STR(SQL_VARBINARY);
 152         SQLTYPE_TO_STR(SQL_LONGVARBINARY);
 153         SQLTYPE_TO_STR(SQL_TYPE_DATE);
 154         SQLTYPE_TO_STR(SQL_DATE);
 155         SQLTYPE_TO_STR(SQL_TIME);
 156         SQLTYPE_TO_STR(SQL_TYPE_TIMESTAMP);
 157         SQLTYPE_TO_STR(SQL_TIMESTAMP);
 158         SQLTYPE_TO_STR(SQL_TYPE_TIME);
 159         SQLTYPE_TO_STR(SQL_BIGINT);
 160         SQLTYPE_TO_STR(SQL_C_SBIGINT);
 161         SQLTYPE_TO_STR(SQL_C_SLONG);
 162         SQLTYPE_TO_STR(SQL_C_ULONG);
 163         SQLTYPE_TO_STR(SQL_WLONGVARCHAR);
 164         SQLTYPE_TO_STR(SQL_WCHAR);
 165         SQLTYPE_TO_STR(SQL_WVARCHAR);
 166         default:
 167              return "Unknown";
 168     }
 169 }
 170
 171 static const char *debugstr_dbtype(DBTYPE type)
 172 {
 173     switch(type)
 174     {
 175         SQLTYPE_TO_STR(DBTYPE_NUMERIC);
 176         SQLTYPE_TO_STR(DBTYPE_STR);
 177         SQLTYPE_TO_STR(DBTYPE_GUID);
 178         SQLTYPE_TO_STR(DBTYPE_I1);
 179         SQLTYPE_TO_STR(DBTYPE_I2);
 180         SQLTYPE_TO_STR(DBTYPE_UI2);
 181         SQLTYPE_TO_STR(DBTYPE_I4);
 182         SQLTYPE_TO_STR(DBTYPE_I8);
 183         SQLTYPE_TO_STR(DBTYPE_UI4);
 184         SQLTYPE_TO_STR(DBTYPE_R4);
 185         SQLTYPE_TO_STR(DBTYPE_R8);
 186         SQLTYPE_TO_STR(DBTYPE_BYTES);
 187         SQLTYPE_TO_STR(DBTYPE_DBDATE);
 188         SQLTYPE_TO_STR(DBTYPE_DBTIME);
 189         SQLTYPE_TO_STR(DBTYPE_DATE);
 190         SQLTYPE_TO_STR(DBTYPE_DBTIMESTAMP);
 191         SQLTYPE_TO_STR(DBTYPE_WSTR);
 192         default:
 193              return "Unknown";
 194     }
 195 }
 196
 197 static SQLSMALLINT sqltype_to_bindtype(SQLSMALLINT type, BOOL sign)
 198 {
 199     switch (type)
 200     {
 201         case SQL_DECIMAL:
 202             return DBTYPE_NUMERIC;
 203         case SQL_CHAR:
 204         case SQL_VARCHAR:
 205         case SQL_LONGVARCHAR:
 206         case SQL_NUMERIC:
 207             return DBTYPE_STR;
 208         case SQL_GUID:
 209             return DBTYPE_GUID;
 210         case SQL_TINYINT:
 211             return DBTYPE_I1;
 212         case SQL_SMALLINT:
 213             return sign ? DBTYPE_I2 : DBTYPE_UI2;
 214         case SQL_INTEGER:
 215             return sign ? DBTYPE_I4 : DBTYPE_UI4;
 216         case SQL_REAL:
 217             return DBTYPE_R4;
 218         case SQL_FLOAT:
 219         case SQL_DOUBLE:
 220             return DBTYPE_R8;
 221         case SQL_BINARY:
 222         case SQL_VARBINARY:
 223         case SQL_LONGVARBINARY:
 224             return DBTYPE_BYTES;
 225         case SQL_TYPE_DATE:
 226             return DBTYPE_DBDATE;
 227         case SQL_DATE:
 228             return DBTYPE_DBTIME;
 229         case SQL_TIME:
 230             return DBTYPE_DATE;
 231         case SQL_TYPE_TIMESTAMP:
 232         case SQL_TIMESTAMP:
 233             return DBTYPE_DBTIMESTAMP;
 234         case SQL_TYPE_TIME:
 235             return DBTYPE_DBTIME;
 236         case SQL_BIGINT:
 237         case SQL_C_SBIGINT:
 238             return DBTYPE_I8;
 239         case SQL_C_SLONG:
 240             return DBTYPE_I4;
 241         case SQL_C_ULONG:
 242             return DBTYPE_UI4;
 243         case SQL_WLONGVARCHAR:
 244         case SQL_WCHAR:
 245         case SQL_WVARCHAR:
 246             return DBTYPE_WSTR;
 247         default:
 248             FIXME("Unsupported type %i\n", type);
 249     }
 250
 251     return DBTYPE_I4;
 252 }
 253
 254 static BOOL is_variable_length(SQLSMALLINT type)
 255 {
 256     switch(type)
 257     {
 258         case SQL_LONGVARCHAR:
 259         case SQL_WLONGVARCHAR:
 260         case SQL_LONGVARBINARY:
 261             return TRUE;
 262     }
 263     return FALSE;
 264 }
 265
 266 static BOOL is_fixed_length(SQLSMALLINT type)
 267 {
 268     switch(type)
 269     {
 270         case SQL_LONGVARCHAR:
 271         case SQL_WLONGVARCHAR:
 272         case SQL_WVARCHAR:
 273         case SQL_LONGVARBINARY:
 274         case SQL_VARBINARY:
 275             return FALSE;
 276     }
 277     return TRUE;
 278 }
 279
 280 struct msdasql_session
 281 {
 282     IUnknown session_iface;
 283     IGetDataSource IGetDataSource_iface;
 284     IOpenRowset    IOpenRowset_iface;
 285     ISessionProperties ISessionProperties_iface;
 286     IDBCreateCommand IDBCreateCommand_iface;
 287     ITransactionJoin ITransactionJoin_iface;
 288     ITransaction ITransaction_iface;
 289     LONG refs;
 290
 291     IUnknown *datasource;
 292
 293     HDBC hdbc;
 294 };
 295
 296 static inline struct msdasql_session *impl_from_IUnknown( IUnknown *iface )
 297 {
 298     return CONTAINING_RECORD( iface, struct msdasql_session, session_iface );
 299 }
 300
 301 static inline struct msdasql_session *impl_from_IGetDataSource( IGetDataSource *iface )
 302 {
 303     return CONTAINING_RECORD( iface, struct msdasql_session, IGetDataSource_iface );
 304 }
 305
 306 static inline struct msdasql_session *impl_from_IOpenRowset( IOpenRowset *iface )
 307 {
 308     return CONTAINING_RECORD( iface, struct msdasql_session, IOpenRowset_iface );
 309 }
 310
 311 static inline struct msdasql_session *impl_from_ISessionProperties( ISessionProperties *iface )
 312 {
 313     return CONTAINING_RECORD( iface, struct msdasql_session, ISessionProperties_iface );
 314 }
 315
 316 static inline struct msdasql_session *impl_from_IDBCreateCommand( IDBCreateCommand *iface )
 317 {
 318     return CONTAINING_RECORD( iface, struct msdasql_session, IDBCreateCommand_iface );
 319 }
 320
 321 static inline struct msdasql_session *impl_from_ITransactionJoin( ITransactionJoin *iface )
 322 {
 323     return CONTAINING_RECORD( iface, struct msdasql_session, ITransactionJoin_iface );
 324 }
 325
 326 static inline struct msdasql_session *impl_from_ITransaction( ITransaction *iface )
 327 {
 328     return CONTAINING_RECORD( iface, struct msdasql_session, ITransaction_iface );
 329 }
 330
 331 static HRESULT WINAPI session_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 332 {
 333     struct msdasql_session *session = impl_from_IUnknown( iface );
 334
 335     TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), ppv );
 336     *ppv = NULL;
 337
 338     if(IsEqualGUID(&IID_IUnknown, riid))
 339     {
 340         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 341         *ppv = &session->session_iface;
 342     }
 343     else if(IsEqualGUID(&IID_IGetDataSource, riid))
 344     {
 345         TRACE("(%p)->(IID_IGetDataSource %p)\n", iface, ppv);
 346         *ppv = &session->IGetDataSource_iface;
 347     }
 348     else if(IsEqualGUID(&IID_IOpenRowset, riid))
 349     {
 350         TRACE("(%p)->(IID_IOpenRowset %p)\n", iface, ppv);
 351         *ppv = &session->IOpenRowset_iface;
 352     }
 353     else if(IsEqualGUID(&IID_ISessionProperties, riid))
 354     {
 355         TRACE("(%p)->(IID_ISessionProperties %p)\n", iface, ppv);
 356         *ppv = &session->ISessionProperties_iface;
 357     }
 358     else if(IsEqualGUID(&IID_IDBCreateCommand, riid))
 359     {
 360         TRACE("(%p)->(IDBCreateCommand_iface %p)\n", iface, ppv);
 361         *ppv = &session->IDBCreateCommand_iface;
 362     }
 363     else if(IsEqualGUID(&IID_ITransactionJoin, riid))
 364     {
 365         TRACE("(%p)->(ITransactionJoin %p)\n", iface, ppv);
 366         *ppv = &session->ITransactionJoin_iface;
 367     }
 368     else if(IsEqualGUID(&IID_ITransaction, riid))
 369     {
 370         TRACE("(%p)->(ITransaction %p)\n", iface, ppv);
 371         *ppv = &session->ITransaction_iface;
 372     }
 373     else if(IsEqualGUID(&IID_IBindResource, riid))
 374     {
 375         TRACE("(%p)->(IID_IBindResource not support)\n", iface);
 376         return E_NOINTERFACE;
 377     }
 378     else if(IsEqualGUID(&IID_ICreateRow, riid))
 379     {
 380         TRACE("(%p)->(IID_ICreateRow not support)\n", iface);
 381         return E_NOINTERFACE;
 382     }
 383
 384     if(*ppv)
 385     {
 386         IUnknown_AddRef((IUnknown*)*ppv);
 387         return S_OK;
 388     }
 389
 390     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 391     return E_NOINTERFACE;
 392 }
 393
 394 static ULONG WINAPI session_AddRef(IUnknown *iface)
 395 {
 396     struct msdasql_session *session = impl_from_IUnknown( iface );
 397     LONG refs = InterlockedIncrement( &session->refs );
 398     TRACE( "%p new refcount %ld\n", session, refs );
 399     return refs;
 400 }
 401
 402 static ULONG WINAPI session_Release(IUnknown *iface)
 403 {
 404     struct msdasql_session *session = impl_from_IUnknown( iface );
 405     LONG refs = InterlockedDecrement( &session->refs );
 406     TRACE( "%p new refcount %ld\n", session, refs );
 407     if (!refs)
 408     {
 409         TRACE( "destroying %p\n", session );
 410
 411         IUnknown_Release(session->datasource);
 412         heap_free( session );
 413     }
 414     return refs;
 415 }
 416
 417 static const IUnknownVtbl unkfactoryVtbl =
 418 {
 419     session_QueryInterface,
 420     session_AddRef,
 421     session_Release,
 422 };
 423
 424
 425 HRESULT WINAPI datasource_QueryInterface(IGetDataSource *iface, REFIID riid, void **out)
 426 {
 427     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 428     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 429 }
 430
 431 ULONG WINAPI datasource_AddRef(IGetDataSource *iface)
 432 {
 433     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 434     return IUnknown_AddRef(&session->session_iface);
 435 }
 436
 437 ULONG WINAPI datasource_Release(IGetDataSource *iface)
 438 {
 439     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 440     return IUnknown_Release(&session->session_iface);
 441 }
 442
 443 HRESULT WINAPI datasource_GetDataSource(IGetDataSource *iface, REFIID riid, IUnknown **datasource)
 444 {
 445     struct msdasql_session *session = impl_from_IGetDataSource( iface );
 446
 447     TRACE("%p, %s, %p stub\n", session, debugstr_guid(riid), datasource);
 448
 449     if (!datasource)
 450         return E_INVALIDARG;
 451
 452     return IUnknown_QueryInterface(session->datasource, riid, (void**)datasource);
 453 }
 454
 455 static const IGetDataSourceVtbl datasourceVtbl =
 456 {
 457     datasource_QueryInterface,
 458     datasource_AddRef,
 459     datasource_Release,
 460     datasource_GetDataSource
 461 };
 462
 463 HRESULT WINAPI openrowset_QueryInterface(IOpenRowset *iface, REFIID riid, void **out)
 464 {
 465     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 466     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 467 }
 468
 469 ULONG WINAPI openrowset_AddRef(IOpenRowset *iface)
 470 {
 471     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 472     return IUnknown_AddRef(&session->session_iface);
 473 }
 474
 475 ULONG WINAPI openrowset_Release(IOpenRowset *iface)
 476 {
 477     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 478     return IUnknown_Release(&session->session_iface);
 479 }
 480
 481 HRESULT WINAPI openrowset_OpenRowset(IOpenRowset *iface, IUnknown *pUnkOuter, DBID *table,
 482             DBID *index, REFIID riid, ULONG count, DBPROPSET propertysets[], IUnknown **rowset)
 483 {
 484     struct msdasql_session *session = impl_from_IOpenRowset( iface );
 485     FIXME("%p, %p, %p %p %s, %ld %p %p stub\n", session, pUnkOuter, table, index, debugstr_guid(riid),
 486             count, propertysets, rowset);
 487
 488     return E_NOTIMPL;
 489 }
 490
 491 static const IOpenRowsetVtbl openrowsetVtbl =
 492 {
 493     openrowset_QueryInterface,
 494     openrowset_AddRef,
 495     openrowset_Release,
 496     openrowset_OpenRowset
 497 };
 498
 499 static HRESULT WINAPI properties_QueryInterface(ISessionProperties *iface, REFIID riid, void **out)
 500 {
 501     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 502     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 503 }
 504
 505 static ULONG WINAPI properties_AddRef(ISessionProperties *iface)
 506 {
 507     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 508     return IUnknown_AddRef(&session->session_iface);
 509 }
 510
 511 static ULONG WINAPI properties_Release(ISessionProperties *iface)
 512 {
 513     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 514     return IUnknown_Release(&session->session_iface);
 515 }
 516
 517
 518 static HRESULT WINAPI properties_GetProperties(ISessionProperties *iface, ULONG set_count,
 519     const DBPROPIDSET id_sets[], ULONG *count, DBPROPSET **sets)
 520 {
 521     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 522     FIXME("%p %lu %p %p %p\n", session, set_count, id_sets, count, sets);
 523
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI properties_SetProperties(ISessionProperties *iface, ULONG count,
 528     DBPROPSET sets[])
 529 {
 530     struct msdasql_session *session = impl_from_ISessionProperties( iface );
 531     FIXME("%p %lu %p\n", session, count, sets);
 532
 533     return S_OK;
 534 }
 535
 536 static const ISessionPropertiesVtbl propertiesVtbl =
 537 {
 538     properties_QueryInterface,
 539     properties_AddRef,
 540     properties_Release,
 541     properties_GetProperties,
 542     properties_SetProperties
 543 };
 544
 545 static HRESULT WINAPI createcommand_QueryInterface(IDBCreateCommand *iface, REFIID riid, void **out)
 546 {
 547     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
 548     return IUnknown_QueryInterface(&session->session_iface, riid, out);
 549 }
 550
 551 static ULONG WINAPI createcommand_AddRef(IDBCreateCommand *iface)
 552 {
 553     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
 554     return IUnknown_AddRef(&session->session_iface);
 555 }
 556
 557 static ULONG WINAPI createcommand_Release(IDBCreateCommand *iface)
 558 {
 559     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
 560     return IUnknown_Release(&session->session_iface);
 561 }
 562
 563 struct command
 564 {
 565     ICommandText ICommandText_iface;
 566     ICommandProperties ICommandProperties_iface;
 567     IColumnsInfo IColumnsInfo_iface;
 568     IConvertType IConvertType_iface;
 569     ICommandPrepare ICommandPrepare_iface;
 570     ICommandWithParameters ICommandWithParameters_iface;
 571     LONG refs;
 572     WCHAR *query;
 573     IUnknown *session;
 574     HDBC hdbc;
 575     SQLHSTMT hstmt;
 576
 577     struct msdasql_prop *properties;
 578     LONG prop_count;
 579 };
 580
 581 static inline struct command *impl_from_ICommandText( ICommandText *iface )
 582 {
 583     return CONTAINING_RECORD( iface, struct command, ICommandText_iface );
 584 }
 585
 586 static inline struct command *impl_from_ICommandProperties( ICommandProperties *iface )
 587 {
 588     return CONTAINING_RECORD( iface, struct command, ICommandProperties_iface );
 589 }
 590
 591 static inline struct command *impl_from_IColumnsInfo( IColumnsInfo *iface )
 592 {
 593     return CONTAINING_RECORD( iface, struct command, IColumnsInfo_iface );
 594 }
 595
 596 static inline struct command *impl_from_IConvertType( IConvertType *iface )
 597 {
 598     return CONTAINING_RECORD( iface, struct command, IConvertType_iface );
 599 }
 600
 601 static inline struct command *impl_from_ICommandPrepare( ICommandPrepare *iface )
 602 {
 603     return CONTAINING_RECORD( iface, struct command, ICommandPrepare_iface );
 604 }
 605
 606 static inline struct command *impl_from_ICommandWithParameters( ICommandWithParameters *iface )
 607 {
 608     return CONTAINING_RECORD( iface, struct command, ICommandWithParameters_iface );
 609 }
 610
 611 static HRESULT WINAPI command_QueryInterface(ICommandText *iface, REFIID riid, void **ppv)
 612 {
 613     struct command *command = impl_from_ICommandText( iface );
 614
 615     TRACE( "%p, %s, %p\n", command, debugstr_guid(riid), ppv );
 616     *ppv = NULL;
 617
 618     if(IsEqualGUID(&IID_IUnknown, riid) ||
 619        IsEqualGUID(&IID_ICommand, riid) ||
 620        IsEqualGUID(&IID_ICommandText, riid))
 621     {
 622         *ppv = &command->ICommandText_iface;
 623     }
 624     else if(IsEqualGUID(&IID_ICommandProperties, riid))
 625     {
 626          *ppv = &command->ICommandProperties_iface;
 627     }
 628     else if(IsEqualGUID(&IID_IColumnsInfo, riid))
 629     {
 630          *ppv = &command->IColumnsInfo_iface;
 631     }
 632     else if(IsEqualGUID(&IID_IConvertType, riid))
 633     {
 634          *ppv = &command->IConvertType_iface;
 635     }
 636     else if(IsEqualGUID(&IID_ICommandPrepare, riid))
 637     {
 638          *ppv = &command->ICommandPrepare_iface;
 639     }
 640     else if(IsEqualGUID(&IID_ICommandWithParameters, riid))
 641     {
 642         *ppv = &command->ICommandWithParameters_iface;
 643     }
 644
 645     if(*ppv)
 646     {
 647         IUnknown_AddRef((IUnknown*)*ppv);
 648         return S_OK;
 649     }
 650     else if (IsEqualGUID(&IID_IMultipleResults, riid))
 651     {
 652         TRACE("IID_IMultipleResults not supported\n");
 653         return E_NOINTERFACE;
 654     }
 655     else if(IsEqualGUID(&IID_ICommandStream, riid))
 656     {
 657         TRACE("ICommandStream not support\n");
 658         return E_NOINTERFACE;
 659     }
 660     else if (IsEqualGUID(&IID_IRowsetChange, riid))
 661     {
 662         TRACE("IID_IRowsetChange not supported\n");
 663         return E_NOINTERFACE;
 664     }
 665     else if (IsEqualGUID(&IID_IRowsetUpdate, riid))
 666     {
 667         TRACE("IID_IRowsetUpdate not supported\n");
 668         return E_NOINTERFACE;
 669     }
 670     else if (IsEqualGUID(&IID_IRowsetLocate, riid))
 671     {
 672         TRACE("IID_IRowsetLocate not supported\n");
 673         return E_NOINTERFACE;
 674     }
 675
 676     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 677     return E_NOINTERFACE;
 678 }
 679
 680 static ULONG WINAPI command_AddRef(ICommandText *iface)
 681 {
 682     struct command *command = impl_from_ICommandText( iface );
 683     LONG refs = InterlockedIncrement( &command->refs );
 684     TRACE( "%p new refcount %ld\n", command, refs );
 685     return refs;
 686 }
 687
 688 static ULONG WINAPI command_Release(ICommandText *iface)
 689 {
 690     struct command *command = impl_from_ICommandText( iface );
 691     LONG refs = InterlockedDecrement( &command->refs );
 692     TRACE( "%p new refcount %ld\n", command, refs );
 693     if (!refs)
 694     {
 695         TRACE( "destroying %p\n", command );
 696         heap_free(command->properties);
 697         if (command->session)
 698             IUnknown_Release(command->session);
 699
 700         if (command->hstmt)
 701             SQLFreeHandle(SQL_HANDLE_STMT, command->hstmt);
 702
 703         heap_free( command->query );
 704         heap_free( command );
 705     }
 706     return refs;
 707 }
 708
 709 static HRESULT WINAPI command_Cancel(ICommandText *iface)
 710 {
 711     struct command *command = impl_from_ICommandText( iface );
 712     FIXME("%p\n", command);
 713     return E_NOTIMPL;
 714 }
 715
 716 struct msdasql_rowset
 717 {
 718     IRowset IRowset_iface;
 719     IRowsetInfo IRowsetInfo_iface;
 720     IColumnsInfo IColumnsInfo_iface;
 721     IAccessor IAccessor_iface;
 722     IColumnsRowset IColumnsRowset_iface;
 723     IUnknown *caller;
 724     LONG refs;
 725     SQLHSTMT hstmt;
 726 };
 727
 728 static inline struct msdasql_rowset *impl_from_IRowset( IRowset *iface )
 729 {
 730     return CONTAINING_RECORD( iface, struct msdasql_rowset, IRowset_iface );
 731 }
 732
 733 static inline struct msdasql_rowset *impl_from_IRowsetInfo( IRowsetInfo *iface )
 734 {
 735     return CONTAINING_RECORD( iface, struct msdasql_rowset, IRowsetInfo_iface );
 736 }
 737
 738 static inline struct msdasql_rowset *rowset_impl_from_IColumnsInfo( IColumnsInfo *iface )
 739 {
 740     return CONTAINING_RECORD( iface, struct msdasql_rowset, IColumnsInfo_iface );
 741 }
 742
 743 static inline struct msdasql_rowset *impl_from_IAccessor ( IAccessor *iface )
 744 {
 745     return CONTAINING_RECORD( iface, struct msdasql_rowset, IAccessor_iface );
 746 }
 747
 748 static inline struct msdasql_rowset *impl_from_IColumnsRowset ( IColumnsRowset *iface )
 749 {
 750     return CONTAINING_RECORD( iface, struct msdasql_rowset, IColumnsRowset_iface );
 751 }
 752
 753 static HRESULT WINAPI msdasql_rowset_QueryInterface(IRowset *iface, REFIID riid,  void **ppv)
 754 {
 755     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 756
 757     TRACE( "%p, %s, %p\n", rowset, debugstr_guid(riid), ppv );
 758
 759     *ppv = NULL;
 760     if(IsEqualGUID(&IID_IUnknown, riid) ||
 761        IsEqualGUID(&IID_IRowset, riid))
 762     {
 763         *ppv = &rowset->IRowset_iface;
 764     }
 765     else if (IsEqualGUID(&IID_IRowsetInfo, riid))
 766     {
 767         *ppv = &rowset->IRowsetInfo_iface;
 768     }
 769     else if (IsEqualGUID(&IID_IColumnsInfo, riid))
 770     {
 771         *ppv = &rowset->IColumnsInfo_iface;
 772     }
 773     else if(IsEqualGUID(&IID_IAccessor, riid))
 774     {
 775          *ppv = &rowset->IAccessor_iface;
 776     }
 777     else if(IsEqualGUID(&IID_IColumnsRowset, riid))
 778     {
 779          *ppv = &rowset->IColumnsRowset_iface;
 780     }
 781     else if (IsEqualGUID(&IID_IRowsetChange, riid))
 782     {
 783         TRACE("IID_IRowsetChange not supported\n");
 784         return E_NOINTERFACE;
 785     }
 786     else if (IsEqualGUID(&IID_IRowsetUpdate, riid))
 787     {
 788         TRACE("IID_IRowsetUpdate not supported\n");
 789         return E_NOINTERFACE;
 790     }
 791     else if (IsEqualGUID(&IID_IRowsetLocate, riid))
 792     {
 793         TRACE("IID_IRowsetLocate not supported\n");
 794         return E_NOINTERFACE;
 795     }
 796
 797     if(*ppv)
 798     {
 799         IUnknown_AddRef((IUnknown*)*ppv);
 800         return S_OK;
 801     }
 802
 803     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 804     return E_NOINTERFACE;
 805 }
 806
 807 static ULONG WINAPI msdasql_rowset_AddRef(IRowset *iface)
 808 {
 809     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 810     LONG refs = InterlockedIncrement( &rowset->refs );
 811     TRACE( "%p new refcount %ld\n", rowset, refs );
 812     return refs;
 813 }
 814
 815 static ULONG WINAPI msdasql_rowset_Release(IRowset *iface)
 816 {
 817     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 818     LONG refs = InterlockedDecrement( &rowset->refs );
 819     TRACE( "%p new refcount %ld\n", rowset, refs );
 820     if (!refs)
 821     {
 822         TRACE( "destroying %p\n", rowset );
 823
 824         SQLFreeHandle(SQL_HANDLE_STMT, rowset->hstmt);
 825
 826         if (rowset->caller)
 827             IUnknown_Release(rowset->caller);
 828
 829         heap_free( rowset );
 830     }
 831     return refs;
 832 }
 833
 834 static HRESULT WINAPI msdasql_rowset_AddRefRows(IRowset *iface, DBCOUNTITEM count,
 835         const HROW rows[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
 836 {
 837     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 838     FIXME("%p, %Id, %p, %p, %p\n", rowset, count, rows, ref_counts, status);
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI msdasql_rowset_GetData(IRowset *iface, HROW row, HACCESSOR accessor, void *data)
 843 {
 844     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 845     FIXME("%p, %Id, %Id, %p\n", rowset, row, accessor, data);
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI msdasql_rowset_GetNextRows(IRowset *iface, HCHAPTER reserved, DBROWOFFSET offset,
 850         DBROWCOUNT count, DBCOUNTITEM *obtained, HROW **rows)
 851 {
 852     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 853     FIXME("%p, %Id, %Id, %Id, %p, %p\n", rowset, reserved, offset, count, obtained, rows);
 854     return E_NOTIMPL;
 855 }
 856
 857 static HRESULT WINAPI msdasql_rowset_ReleaseRows(IRowset *iface, DBCOUNTITEM count,
 858         const HROW rows[], DBROWOPTIONS options[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
 859 {
 860     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 861
 862     FIXME("%p, %Id, %p, %p, %p, %p\n", rowset, count, rows, options, ref_counts, status);
 863     return E_NOTIMPL;
 864 }
 865
 866 static HRESULT WINAPI msdasql_rowset_RestartPosition(IRowset *iface, HCHAPTER reserved)
 867 {
 868     struct msdasql_rowset *rowset = impl_from_IRowset( iface );
 869     FIXME("%p, %Id\n", rowset, reserved);
 870     return E_NOTIMPL;
 871 }
 872
 873 static const struct IRowsetVtbl msdasql_rowset_vtbl =
 874 {
 875     msdasql_rowset_QueryInterface,
 876     msdasql_rowset_AddRef,
 877     msdasql_rowset_Release,
 878     msdasql_rowset_AddRefRows,
 879     msdasql_rowset_GetData,
 880     msdasql_rowset_GetNextRows,
 881     msdasql_rowset_ReleaseRows,
 882     msdasql_rowset_RestartPosition
 883 };
 884
 885 static HRESULT WINAPI rowset_info_QueryInterface(IRowsetInfo *iface, REFIID riid, void **ppv)
 886 {
 887     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 888     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, ppv);
 889 }
 890
 891 static ULONG WINAPI rowset_info_AddRef(IRowsetInfo *iface)
 892 {
 893     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 894     return IRowset_AddRef(&rowset->IRowset_iface);
 895 }
 896
 897 static ULONG WINAPI rowset_info_Release(IRowsetInfo *iface)
 898 {
 899     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 900     return IRowset_Release(&rowset->IRowset_iface);
 901 }
 902
 903 static HRESULT WINAPI rowset_info_GetProperties(IRowsetInfo *iface, const ULONG count,
 904         const DBPROPIDSET propertyidsets[], ULONG *out_count, DBPROPSET **propertysets)
 905 {
 906     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 907     HRESULT hr;
 908     ICommandProperties *props;
 909
 910     TRACE("%p, %lu, %p, %p, %p\n", rowset, count, propertyidsets, out_count, propertysets);
 911
 912     hr = IUnknown_QueryInterface(rowset->caller, &IID_ICommandProperties, (void**)&props);
 913     if (FAILED(hr))
 914         return hr;
 915
 916     hr = ICommandProperties_GetProperties(props, count, propertyidsets, out_count, propertysets);
 917     ICommandProperties_Release(props);
 918
 919     return hr;
 920 }
 921
 922 static HRESULT WINAPI rowset_info_GetReferencedRowset(IRowsetInfo *iface, DBORDINAL ordinal,
 923         REFIID riid, IUnknown **unk)
 924 {
 925     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 926     FIXME("%p, %Id, %s, %p\n", rowset, ordinal, debugstr_guid(riid), unk);
 927     return E_NOTIMPL;
 928 }
 929
 930 static HRESULT WINAPI rowset_info_GetSpecification(IRowsetInfo *iface, REFIID riid,
 931         IUnknown **specification)
 932 {
 933     struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
 934
 935     TRACE("%p, %s, %p\n", rowset, debugstr_guid(riid), specification);
 936
 937     if (!specification)
 938         return E_INVALIDARG;
 939
 940     if (!rowset->caller)
 941         return S_FALSE;
 942
 943     return IUnknown_QueryInterface(rowset->caller, riid, (void**)specification);
 944 }
 945
 946 struct IRowsetInfoVtbl rowset_info_vtbl =
 947 {
 948     rowset_info_QueryInterface,
 949     rowset_info_AddRef,
 950     rowset_info_Release,
 951     rowset_info_GetProperties,
 952     rowset_info_GetReferencedRowset,
 953     rowset_info_GetSpecification
 954 };
 955
 956 static HRESULT WINAPI rowset_colsinfo_QueryInterface(IColumnsInfo *iface, REFIID riid, void **out)
 957 {
 958     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 959     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
 960 }
 961
 962 static ULONG WINAPI rowset_colsinfo_AddRef(IColumnsInfo *iface)
 963 {
 964     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 965     return IRowset_AddRef(&rowset->IRowset_iface);
 966 }
 967
 968 static ULONG  WINAPI rowset_colsinfo_Release(IColumnsInfo *iface)
 969 {
 970     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 971     return IRowset_Release(&rowset->IRowset_iface);
 972 }
 973
 974 static HRESULT WINAPI rowset_colsinfo_GetColumnInfo(IColumnsInfo *iface, DBORDINAL *columns,
 975         DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
 976 {
 977 #define MAX_COLUMN_LEN 128
 978
 979     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
 980     DBCOLUMNINFO *dbcolumn;
 981     RETCODE ret;
 982     SQLSMALLINT colcnt;
 983     int i;
 984     OLECHAR *ptr;
 985
 986     TRACE("%p, %p, %p, %p\n", rowset, columns, colinfo, stringsbuffer);
 987
 988     if (!columns || !colinfo || !stringsbuffer)
 989         return E_INVALIDARG;
 990
 991     SQLNumResultCols(rowset->hstmt, &colcnt);
 992     TRACE("SQLNumResultCols %d\n", colcnt);
 993
 994     *columns = colcnt;
 995
 996     ptr = *stringsbuffer = CoTaskMemAlloc(colcnt * MAX_COLUMN_LEN * sizeof(WCHAR));
 997     if (!ptr)
 998         return E_OUTOFMEMORY;
 999
1000     dbcolumn = CoTaskMemAlloc(colcnt * sizeof(DBCOLUMNINFO));
1001     if (!dbcolumn)
1002     {
1003         CoTaskMemFree(ptr);
1004         return E_OUTOFMEMORY;
1005     }
1006
1007     for (i = 0; i < colcnt; i++)
1008     {
1009         SQLWCHAR      columnname[MAX_COLUMN_LEN];
1010         SQLSMALLINT   ColumnNameLen;
1011         SQLSMALLINT   ColumnDataType;
1012         SQLULEN       ColumnDataSize;
1013         SQLSMALLINT   ColumnDataDigits;
1014         SQLSMALLINT   ColumnDataNullable;
1015
1016         ret = SQLDescribeColW(rowset->hstmt, i+1, columnname, MAX_COLUMN_LEN, &ColumnNameLen, &ColumnDataType,
1017                     &ColumnDataSize, &ColumnDataDigits, &ColumnDataNullable);
1018         if (SQL_SUCCEEDED(ret))
1019         {
1020             SQLLEN  length;
1021
1022             TRACE("%d: Column Name : %s, Column Name Len : %i, SQL Data Type : %i, Data Size : %i, DecimalDigits : %i, Nullable %i\n",
1023                  i, debugstr_w(columnname), (int)ColumnNameLen, (int)ColumnDataType, (int)ColumnDataSize, (int)ColumnDataDigits,
1024                  (int)ColumnDataNullable);
1025             lstrcpyW(ptr, columnname);
1026
1027             dbcolumn[i].pwszName = ptr;
1028             dbcolumn[i].pTypeInfo = NULL;
1029             dbcolumn[i].iOrdinal = i+1;
1030
1031             ret = SQLColAttributesW (rowset->hstmt, i+1, SQL_DESC_UNSIGNED, NULL, 0, NULL, &length);
1032             if (!SQL_SUCCEEDED(ret))
1033             {
1034                 dump_sql_diag_records(SQL_HANDLE_STMT, rowset->hstmt);
1035                 CoTaskMemFree(ptr);
1036                 CoTaskMemFree(dbcolumn);
1037                 ERR("Failed to get column %d attribute\n", i+1);
1038                 return E_FAIL;
1039             }
1040
1041             dbcolumn[i].wType = sqltype_to_bindtype(ColumnDataType, length == SQL_FALSE);
1042             TRACE("SQLType %s -> %s\n", debugstr_sqltype(ColumnDataType), debugstr_dbtype(dbcolumn[i].wType));
1043
1044             dbcolumn[i].dwFlags = DBCOLUMNFLAGS_WRITE;
1045
1046             ret = SQLColAttributesW(rowset->hstmt, i+1, SQL_DESC_LENGTH, NULL, 0, NULL, &length);
1047             if (!SQL_SUCCEEDED(ret))
1048             {
1049                 CoTaskMemFree(ptr);
1050                 CoTaskMemFree(dbcolumn);
1051                 ERR("Failed to get column %d length (%d)\n", i+1, ret);
1052                 return E_FAIL;
1053             }
1054             dbcolumn[i].ulColumnSize = length;
1055
1056             if (dbcolumn[i].ulColumnSize > 1024 && is_variable_length(ColumnDataType))
1057                 dbcolumn[i].dwFlags |= DBCOLUMNFLAGS_MAYDEFER | DBCOLUMNFLAGS_ISLONG;
1058
1059             if (ColumnDataNullable)
1060                 dbcolumn[i].dwFlags |= DBCOLUMNFLAGS_ISNULLABLE | DBCOLUMNFLAGS_MAYBENULL;
1061
1062             if (is_fixed_length(ColumnDataType))
1063                 dbcolumn[i].dwFlags |= DBCOLUMNFLAGS_ISFIXEDLENGTH;
1064
1065             ret = SQLColAttributesW(rowset->hstmt, i+1, SQL_DESC_SCALE, NULL, 0, NULL, &length);
1066             if (!SQL_SUCCEEDED(ret))
1067             {
1068                 CoTaskMemFree(ptr);
1069                 CoTaskMemFree(dbcolumn);
1070                 ERR("Failed to get column %d scale (%d)\n", i+1, ret);
1071                 return E_FAIL;
1072             }
1073             if (length == 0)
1074                 length = 255;
1075             dbcolumn[i].bScale = length;
1076
1077             ret = SQLColAttributesW(rowset->hstmt, i+1, SQL_DESC_PRECISION, NULL, 0, NULL, &length);
1078             if (!SQL_SUCCEEDED(ret))
1079             {
1080                 CoTaskMemFree(ptr);
1081                 CoTaskMemFree(dbcolumn);
1082                 ERR("Failed to get column %d precision (%d)\n", i+1, ret);
1083                 return E_FAIL;
1084             }
1085             if (length == 0)
1086                 length = 255;
1087             dbcolumn[i].bPrecision= length;
1088
1089             dbcolumn[i].columnid.eKind = DBKIND_NAME;
1090             dbcolumn[i].columnid.uName.pwszName = ptr;
1091
1092             ptr += ColumnNameLen + 1;
1093         }
1094         else
1095         {
1096             CoTaskMemFree(ptr);
1097             CoTaskMemFree(dbcolumn);
1098             ERR("Failed to get column %d description (%d)\n", i+1, ret);
1099             return E_FAIL;
1100         }
1101     }
1102
1103     *colinfo = dbcolumn;
1104 #undef MAX_COLUMN_LEN
1105     return S_OK;
1106 }
1107
1108 static HRESULT WINAPI rowset_colsinfo_MapColumnIDs(IColumnsInfo *iface, DBORDINAL column_ids,
1109         const DBID *dbids, DBORDINAL *columns)
1110 {
1111     struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
1112     FIXME("%p, %Id, %p, %p\n", rowset, column_ids, dbids, columns);
1113     return E_NOTIMPL;
1114 }
1115
1116 static struct IColumnsInfoVtbl rowset_columninfo_vtbll =
1117 {
1118     rowset_colsinfo_QueryInterface,
1119     rowset_colsinfo_AddRef,
1120     rowset_colsinfo_Release,
1121     rowset_colsinfo_GetColumnInfo,
1122     rowset_colsinfo_MapColumnIDs
1123 };
1124
1125 static HRESULT WINAPI rowset_accessor_QueryInterface(IAccessor *iface, REFIID riid, void **out)
1126 {
1127     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1128     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
1129 }
1130
1131 static ULONG WINAPI rowset_accessor_AddRef(IAccessor *iface)
1132 {
1133     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1134     return IRowset_AddRef(&rowset->IRowset_iface);
1135 }
1136
1137 static ULONG  WINAPI rowset_accessor_Release(IAccessor *iface)
1138 {
1139     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1140     return IRowset_Release(&rowset->IRowset_iface);
1141 }
1142
1143 static HRESULT WINAPI rowset_accessor_AddRefAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
1144 {
1145     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1146     FIXME("%p, %Id, %p\n", rowset, accessor, count);
1147     return E_NOTIMPL;
1148 }
1149
1150 static HRESULT WINAPI rowset_accessor_CreateAccessor(IAccessor *iface, DBACCESSORFLAGS flags,
1151         DBCOUNTITEM count, const DBBINDING bindings[], DBLENGTH row_size, HACCESSOR *accessor,
1152         DBBINDSTATUS status[])
1153 {
1154     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1155     FIXME("%p, 0x%08lx, %Id, %p, %Id, %p, %p\n", rowset, flags, count, bindings, row_size, accessor, status);
1156     return E_NOTIMPL;
1157 }
1158
1159 static HRESULT WINAPI rowset_accessor_GetBindings(IAccessor *iface, HACCESSOR accessor,
1160         DBACCESSORFLAGS *flags, DBCOUNTITEM *count, DBBINDING **bindings)
1161 {
1162     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1163     FIXME("%p, %Id, %p, %p, %p\n", rowset, accessor, flags, count, bindings);
1164     return E_NOTIMPL;
1165 }
1166
1167 static HRESULT WINAPI rowset_accessor_ReleaseAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
1168 {
1169     struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1170     FIXME("%p, %Id, %p\n", rowset, accessor, count);
1171     return E_NOTIMPL;
1172 }
1173
1174 struct IAccessorVtbl accessor_vtbl =
1175 {
1176     rowset_accessor_QueryInterface,
1177     rowset_accessor_AddRef,
1178     rowset_accessor_Release,
1179     rowset_accessor_AddRefAccessor,
1180     rowset_accessor_CreateAccessor,
1181     rowset_accessor_GetBindings,
1182     rowset_accessor_ReleaseAccessor
1183 };
1184
1185 static HRESULT WINAPI column_rs_QueryInterface(IColumnsRowset *iface, REFIID riid, void **out)
1186 {
1187     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1188     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
1189 }
1190
1191 static ULONG WINAPI column_rs_AddRef(IColumnsRowset *iface)
1192 {
1193     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1194     return IRowset_AddRef(&rowset->IRowset_iface);
1195 }
1196
1197 static ULONG WINAPI column_rs_Release(IColumnsRowset *iface)
1198 {
1199     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1200     return IRowset_Release(&rowset->IRowset_iface);
1201 }
1202
1203 static HRESULT WINAPI column_rs_GetAvailableColumns(IColumnsRowset *iface, DBORDINAL *count, DBID **columns)
1204 {
1205     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1206
1207     TRACE("%p, %p, %p\n", rowset, count, columns);
1208
1209     if (!count || !columns)
1210         return E_INVALIDARG;
1211
1212     *count = 0;
1213     *columns = NULL;
1214
1215     return S_OK;
1216 }
1217
1218 static HRESULT WINAPI column_rs_GetColumnsRowset(IColumnsRowset *iface, IUnknown *outer, DBORDINAL count,
1219         const DBID columns[], REFIID riid, ULONG property_cnt, DBPROPSET property_sets[], IUnknown **unk_rs)
1220 {
1221     struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1222     FIXME("(%p)->(%p, %Id, %p, %s, %lu, %p, %p): stub\n", rowset, outer, count, columns, debugstr_guid(riid),
1223           property_cnt, property_sets, unk_rs);
1224     return E_NOTIMPL;
1225 }
1226
1227 struct IColumnsRowsetVtbl columnrs_rs_vtbl =
1228 {
1229     column_rs_QueryInterface,
1230     column_rs_AddRef,
1231     column_rs_Release,
1232     column_rs_GetAvailableColumns,
1233     column_rs_GetColumnsRowset
1234 };
1235
1236 static HRESULT WINAPI command_Execute(ICommandText *iface, IUnknown *outer, REFIID riid,
1237         DBPARAMS *params, DBROWCOUNT *affected, IUnknown **rowset)
1238 {
1239     struct command *command = impl_from_ICommandText( iface );
1240     struct msdasql_rowset *msrowset;
1241     HRESULT hr = S_OK;
1242     RETCODE ret;
1243     SQLHSTMT hstmt = command->hstmt;
1244     SQLLEN results = -1;
1245     BOOL free_hstmt = TRUE;
1246
1247     TRACE("%p, %p, %s, %p %p %p\n", command, outer, debugstr_guid(riid), params, affected, rowset);
1248
1249     if (!hstmt)
1250         SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &hstmt);
1251
1252     ret = SQLExecDirectW(hstmt, command->query, SQL_NTS);
1253     if (ret != SQL_SUCCESS)
1254     {
1255         dump_sql_diag_records(SQL_HANDLE_STMT, hstmt);
1256         return E_FAIL;
1257     }
1258
1259     *rowset = NULL;
1260     if (!wcsnicmp( command->query, L"select ", 7 ))
1261     {
1262         msrowset = heap_alloc(sizeof(*msrowset));
1263         if (!msrowset)
1264             return E_OUTOFMEMORY;
1265
1266         command->hstmt = NULL;
1267
1268         msrowset->IRowset_iface.lpVtbl = &msdasql_rowset_vtbl;
1269         msrowset->IRowsetInfo_iface.lpVtbl = &rowset_info_vtbl;
1270         msrowset->IColumnsInfo_iface.lpVtbl = &rowset_columninfo_vtbll;
1271         msrowset->IAccessor_iface.lpVtbl = &accessor_vtbl;
1272         msrowset->IColumnsRowset_iface.lpVtbl = &columnrs_rs_vtbl;
1273         msrowset->refs = 1;
1274         ICommandText_QueryInterface(iface, &IID_IUnknown, (void**)&msrowset->caller);
1275         msrowset->hstmt = hstmt;
1276         free_hstmt = FALSE;
1277
1278         hr = IRowset_QueryInterface(&msrowset->IRowset_iface, riid, (void**)rowset);
1279         IRowset_Release(&msrowset->IRowset_iface);
1280     }
1281
1282     if (affected)
1283     {
1284         ret = SQLRowCount(hstmt, &results);
1285         if (ret != SQL_SUCCESS)
1286             ERR("SQLRowCount failed (%d)\n", ret);
1287
1288         *affected = results;
1289     }
1290
1291     if (free_hstmt)
1292         SQLFreeStmt(hstmt, SQL_CLOSE);
1293
1294     return hr;
1295 }
1296
1297 static HRESULT WINAPI command_GetDBSession(ICommandText *iface, REFIID riid, IUnknown **session)
1298 {
1299     struct command *command = impl_from_ICommandText( iface );
1300
1301     TRACE("%p, %s, %p\n", command, debugstr_guid(riid), session);
1302
1303     if (!session)
1304         return E_INVALIDARG;
1305
1306     *session = NULL;
1307
1308     if (!command->session)
1309         return S_FALSE;
1310
1311     return IUnknown_QueryInterface(command->session, riid, (void**)session);
1312 }
1313
1314 static HRESULT WINAPI command_GetCommandText(ICommandText *iface, GUID *dialect, LPOLESTR *commandstr)
1315 {
1316     struct command *command = impl_from_ICommandText( iface );
1317     HRESULT hr = S_OK;
1318     TRACE("%p, %p, %p\n", command, dialect, commandstr);
1319
1320     if (!command->query)
1321         return DB_E_NOCOMMAND;
1322
1323     if (dialect && !IsEqualGUID(&DBGUID_DEFAULT, dialect))
1324     {
1325         *dialect = DBGUID_DEFAULT;
1326         hr = DB_S_DIALECTIGNORED;
1327     }
1328
1329     *commandstr = heap_alloc((lstrlenW(command->query)+1)*sizeof(WCHAR));
1330     wcscpy(*commandstr, command->query);
1331     return hr;
1332 }
1333
1334 static HRESULT WINAPI command_SetCommandText(ICommandText *iface, REFGUID dialect, LPCOLESTR commandstr)
1335 {
1336     struct command *command = impl_from_ICommandText( iface );
1337     TRACE("%p, %s, %s\n", command, debugstr_guid(dialect), debugstr_w(commandstr));
1338
1339     if (!IsEqualGUID(&DBGUID_DEFAULT, dialect))
1340         FIXME("Currently non Default Dialect isn't supported\n");
1341
1342     heap_free(command->query);
1343
1344     if (commandstr)
1345     {
1346         command->query = heap_alloc((lstrlenW(commandstr)+1)*sizeof(WCHAR));
1347         if (!command->query)
1348             return E_OUTOFMEMORY;
1349
1350         wcscpy(command->query, commandstr);
1351     }
1352     else
1353         command->query = NULL;
1354     return S_OK;
1355 }
1356
1357 static const ICommandTextVtbl commandVtbl =
1358 {
1359     command_QueryInterface,
1360     command_AddRef,
1361     command_Release,
1362     command_Cancel,
1363     command_Execute,
1364     command_GetDBSession,
1365     command_GetCommandText,
1366     command_SetCommandText
1367 };
1368
1369 static HRESULT WINAPI command_prop_QueryInterface(ICommandProperties *iface, REFIID riid, void **out)
1370 {
1371     struct command *command = impl_from_ICommandProperties( iface );
1372     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1373 }
1374
1375 static ULONG WINAPI command_prop_AddRef(ICommandProperties *iface)
1376 {
1377     struct command *command = impl_from_ICommandProperties( iface );
1378     return ICommandText_AddRef(&command->ICommandText_iface);
1379 }
1380
1381 static ULONG WINAPI command_prop_Release(ICommandProperties *iface)
1382 {
1383     struct command *command = impl_from_ICommandProperties( iface );
1384     return ICommandText_Release(&command->ICommandText_iface);
1385 }
1386
1387 static ULONG get_property_count(DWORD flag, struct msdasql_prop *properties, int prop_count)
1388 {
1389     int i, count = 0;
1390
1391     for(i=0; i < prop_count; i++)
1392     {
1393         if (properties[i].flags & flag)
1394             count++;
1395     }
1396
1397     return count;
1398 }
1399
1400 static HRESULT WINAPI command_prop_GetProperties(ICommandProperties *iface, ULONG count,
1401         const DBPROPIDSET propertyidsets[], ULONG *sets_cnt, DBPROPSET **propertyset)
1402 {
1403     struct command *command = impl_from_ICommandProperties( iface );
1404     DBPROPSET *propset = NULL;
1405     int i, j, k;
1406
1407     TRACE("%p %ld %p %p %p\n", command, count, propertyidsets, sets_cnt, propertyset);
1408
1409     /* All Properties */
1410     if (count == 0)
1411     {
1412         int idx;
1413         propset = CoTaskMemAlloc(2 * sizeof(DBPROPSET));
1414         if (!propset)
1415             return E_OUTOFMEMORY;
1416
1417         propset[0].guidPropertySet = DBPROPSET_ROWSET;
1418         propset[0].cProperties = get_property_count(DBPROPFLAGS_ROWSET, command->properties, command->prop_count);
1419         propset[0].rgProperties = CoTaskMemAlloc(propset[0].cProperties * sizeof(DBPROP));
1420         if (!propset[0].rgProperties)
1421         {
1422             CoTaskMemFree(propset);
1423             return E_OUTOFMEMORY;
1424         }
1425
1426         idx = 0;
1427         for (j=0; j < command->prop_count; j++)
1428         {
1429             if (!(command->properties[j].flags & DBPROPFLAGS_ROWSET))
1430                 continue;
1431             propset[0].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1432
1433             V_VT(&propset[0].rgProperties[idx].vValue) = command->properties[j].vartype;
1434             if (command->properties[j].vartype == VT_BOOL)
1435             {
1436                 V_BOOL(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1437             }
1438             else if (command->properties[j].vartype == VT_I4)
1439             {
1440                 V_I4(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1441             }
1442             else
1443                 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1444
1445             idx++;
1446         }
1447
1448         propset[1].guidPropertySet = DBPROPSET_PROVIDERROWSET;
1449         propset[1].cProperties = get_property_count(DBPROPFLAGS_DATASOURCEINFO, command->properties, command->prop_count);
1450         propset[1].rgProperties = CoTaskMemAlloc(propset[1].cProperties * sizeof(DBPROP));
1451         if (!propset[1].rgProperties)
1452         {
1453             CoTaskMemFree(propset[0].rgProperties);
1454             CoTaskMemFree(propset);
1455             return E_OUTOFMEMORY;
1456         }
1457
1458         idx = 0;
1459         for (j=0; j < command->prop_count; j++)
1460         {
1461             if (!(command->properties[j].flags & DBPROPFLAGS_DATASOURCEINFO))
1462                 continue;
1463             propset[1].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1464
1465             V_VT(&propset[1].rgProperties[idx].vValue) = command->properties[j].vartype;
1466             if (command->properties[j].vartype == VT_BOOL)
1467             {
1468                 V_BOOL(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1469             }
1470             else if (command->properties[j].vartype == VT_I4)
1471             {
1472                 V_I4(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1473             }
1474             else
1475                 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1476
1477             idx++;
1478         }
1479
1480         *sets_cnt = 2;
1481     }
1482     else
1483     {
1484         propset = CoTaskMemAlloc(count * sizeof(DBPROPSET));
1485         if (!propset)
1486             return E_OUTOFMEMORY;
1487
1488         for (i=0; i < count; i++)
1489         {
1490             TRACE("Property id %d (count %ld, set %s)\n", i, propertyidsets[i].cPropertyIDs,
1491                     debugstr_guid(&propertyidsets[i].guidPropertySet));
1492
1493             propset[i].cProperties = propertyidsets[i].cPropertyIDs;
1494             propset[i].rgProperties = CoTaskMemAlloc(propset[i].cProperties * sizeof(DBPROP));
1495
1496             for (j=0; j < propset[i].cProperties; j++)
1497             {
1498                 propset[i].rgProperties[j].dwPropertyID = propertyidsets[i].rgPropertyIDs[j];
1499
1500                 for(k = 0; k < command->prop_count; k++)
1501                 {
1502                     if (command->properties[k].property_id == propertyidsets[i].rgPropertyIDs[j])
1503                     {
1504                         V_VT(&propset[i].rgProperties[i].vValue) = command->properties[j].vartype;
1505                         if (command->properties[j].vartype == VT_BOOL)
1506                         {
1507                             V_BOOL(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1508                         }
1509                         else if (command->properties[j].vartype == VT_I4)
1510                         {
1511                             V_I4(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1512                         }
1513                         else
1514                             ERR("Unknown variant type %d\n", command->properties[j].vartype);
1515                         break;
1516                     }
1517                 }
1518             }
1519         }
1520
1521         *sets_cnt = count;
1522     }
1523
1524     *propertyset = propset;
1525
1526     return S_OK;
1527 }
1528
1529 static HRESULT WINAPI command_prop_SetProperties(ICommandProperties *iface, ULONG count,
1530         DBPROPSET propertyset[])
1531 {
1532     struct command *command = impl_from_ICommandProperties( iface );
1533     int i, j, k;
1534
1535     TRACE("%p %lu, %p\n", command, count, propertyset);
1536
1537     for(i=0; i < count; i++)
1538     {
1539         TRACE("set %s, count %ld\n", debugstr_guid(&propertyset[i].guidPropertySet), propertyset[i].cProperties);
1540         for(j=0; j < propertyset[i].cProperties; j++)
1541         {
1542             for(k=0; k < command->prop_count; k++)
1543             {
1544                 if (command->properties[k].property_id == propertyset[i].rgProperties[j].dwPropertyID)
1545                 {
1546                     TRACE("Found property 0x%08lx\n", command->properties[k].property_id);
1547                     if (command->properties[k].flags & DBPROPFLAGS_WRITE)
1548                     {
1549                         if (command->properties[k].vartype == VT_BOOL)
1550                         {
1551                             command->properties[k].value = V_BOOL(&propertyset[i].rgProperties[j].vValue);
1552                         }
1553                         else if (command->properties[k].vartype == VT_I4)
1554                         {
1555                             command->properties[k].value = V_I4(&propertyset[i].rgProperties[j].vValue);
1556                         }
1557                         else
1558                             ERR("Unknown variant type %d\n", command->properties[j].vartype);
1559                     }
1560                     else
1561                         WARN("Attempting to set Readonly property\n");
1562
1563                     break;
1564                 }
1565             }
1566         }
1567     }
1568     return S_OK;
1569 }
1570
1571 static const ICommandPropertiesVtbl commonpropsVtbl =
1572 {
1573     command_prop_QueryInterface,
1574     command_prop_AddRef,
1575     command_prop_Release,
1576     command_prop_GetProperties,
1577     command_prop_SetProperties
1578 };
1579
1580 static HRESULT WINAPI colsinfo_QueryInterface(IColumnsInfo *iface, REFIID riid, void **out)
1581 {
1582     struct command *command = impl_from_IColumnsInfo( iface );
1583     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1584 }
1585
1586 static ULONG WINAPI colsinfo_AddRef(IColumnsInfo *iface)
1587 {
1588     struct command *command = impl_from_IColumnsInfo( iface );
1589     return ICommandText_AddRef(&command->ICommandText_iface);
1590 }
1591
1592 static ULONG  WINAPI colsinfo_Release(IColumnsInfo *iface)
1593 {
1594     struct command *command = impl_from_IColumnsInfo( iface );
1595     return ICommandText_Release(&command->ICommandText_iface);
1596 }
1597
1598 static HRESULT WINAPI colsinfo_GetColumnInfo(IColumnsInfo *iface, DBORDINAL *columns,
1599         DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
1600 {
1601     struct command *command = impl_from_IColumnsInfo( iface );
1602     FIXME("%p, %p, %p, %p\n", command, columns, colinfo, stringsbuffer);
1603     return E_NOTIMPL;
1604 }
1605
1606 static HRESULT WINAPI colsinfo_MapColumnIDs(IColumnsInfo *iface, DBORDINAL column_ids,
1607         const DBID *dbids, DBORDINAL *columns)
1608 {
1609     struct command *command = impl_from_IColumnsInfo( iface );
1610     FIXME("%p, %Iu, %p, %p\n", command, column_ids, dbids, columns);
1611     return E_NOTIMPL;
1612 }
1613
1614 static struct IColumnsInfoVtbl columninfoVtbl =
1615 {
1616     colsinfo_QueryInterface,
1617     colsinfo_AddRef,
1618     colsinfo_Release,
1619     colsinfo_GetColumnInfo,
1620     colsinfo_MapColumnIDs
1621 };
1622
1623 static HRESULT WINAPI converttype_QueryInterface(IConvertType *iface, REFIID riid, void **out)
1624 {
1625     struct command *command = impl_from_IConvertType( iface );
1626     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1627 }
1628
1629 static ULONG WINAPI converttype_AddRef(IConvertType *iface)
1630 {
1631     struct command *command = impl_from_IConvertType( iface );
1632     return ICommandText_AddRef(&command->ICommandText_iface);
1633 }
1634
1635 static ULONG WINAPI converttype_Release(IConvertType *iface)
1636 {
1637     struct command *command = impl_from_IConvertType( iface );
1638     return ICommandText_Release(&command->ICommandText_iface);
1639 }
1640
1641 static HRESULT WINAPI converttype_CanConvert(IConvertType *iface, DBTYPE from, DBTYPE to, DBCONVERTFLAGS flags)
1642 {
1643     struct command *command = impl_from_IConvertType( iface );
1644     FIXME("%p, %u, %d, 0x%08lx\n", command, from, to, flags);
1645     return E_NOTIMPL;
1646 }
1647
1648 static struct IConvertTypeVtbl converttypeVtbl =
1649 {
1650     converttype_QueryInterface,
1651     converttype_AddRef,
1652     converttype_Release,
1653     converttype_CanConvert
1654 };
1655
1656 static HRESULT WINAPI commandprepare_QueryInterface(ICommandPrepare *iface, REFIID riid, void **out)
1657 {
1658     struct command *command = impl_from_ICommandPrepare( iface );
1659     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1660 }
1661
1662 static ULONG WINAPI commandprepare_AddRef(ICommandPrepare *iface)
1663 {
1664     struct command *command = impl_from_ICommandPrepare( iface );
1665     return ICommandText_AddRef(&command->ICommandText_iface);
1666 }
1667
1668 static ULONG WINAPI commandprepare_Release(ICommandPrepare *iface)
1669 {
1670     struct command *command = impl_from_ICommandPrepare( iface );
1671     return ICommandText_Release(&command->ICommandText_iface);
1672 }
1673
1674 static HRESULT WINAPI commandprepare_Prepare(ICommandPrepare *iface, ULONG runs)
1675 {
1676     struct command *command = impl_from_ICommandPrepare( iface );
1677     RETCODE ret;
1678
1679     TRACE("%p, %lu\n", command, runs);
1680
1681     if (!command->query)
1682         return DB_E_NOCOMMAND;
1683
1684     if (command->hstmt)
1685         SQLFreeHandle(SQL_HANDLE_STMT, command->hstmt);
1686
1687     SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &command->hstmt);
1688
1689     ret = SQLPrepareW(command->hstmt, command->query, SQL_NTS);
1690     if (ret != SQL_SUCCESS)
1691     {
1692         dump_sql_diag_records(SQL_HANDLE_STMT, command->hstmt);
1693         return E_FAIL;
1694     }
1695     return S_OK;
1696 }
1697
1698 static HRESULT WINAPI commandprepare_Unprepare(ICommandPrepare *iface)
1699 {
1700     struct command *command = impl_from_ICommandPrepare( iface );
1701     TRACE("%p\n", command);
1702     return S_OK;
1703 }
1704
1705 struct ICommandPrepareVtbl commandprepareVtbl =
1706 {
1707     commandprepare_QueryInterface,
1708     commandprepare_AddRef,
1709     commandprepare_Release,
1710     commandprepare_Prepare,
1711     commandprepare_Unprepare
1712 };
1713
1714 static HRESULT WINAPI cmd_with_params_QueryInterface(ICommandWithParameters *iface, REFIID riid, void **out)
1715 {
1716     struct command *command = impl_from_ICommandWithParameters( iface );
1717     return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1718 }
1719
1720 static ULONG WINAPI cmd_with_params_AddRef(ICommandWithParameters *iface)
1721 {
1722     struct command *command = impl_from_ICommandWithParameters( iface );
1723     return ICommandText_AddRef(&command->ICommandText_iface);
1724 }
1725
1726 static ULONG WINAPI cmd_with_params_Release(ICommandWithParameters *iface)
1727 {
1728     struct command *command = impl_from_ICommandWithParameters( iface );
1729     return ICommandText_Release(&command->ICommandText_iface);
1730 }
1731
1732 static HRESULT WINAPI cmd_with_params_GetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS *uparams,
1733         DBPARAMINFO **info, OLECHAR **buffer)
1734 {
1735     struct command *command = impl_from_ICommandWithParameters( iface );
1736     FIXME("%p, %p, %p, %p\n", command, uparams, info, buffer);
1737     return E_NOTIMPL;
1738 }
1739
1740 static HRESULT WINAPI cmd_with_params_MapParameterNames(ICommandWithParameters *iface, DB_UPARAMS uparams,
1741         LPCWSTR names[], DB_LPARAMS ordinals[])
1742 {
1743     struct command *command = impl_from_ICommandWithParameters( iface );
1744     FIXME("%p, %Iu, %p, %p\n", command, uparams, names, ordinals);
1745     return E_NOTIMPL;
1746 }
1747
1748 static HRESULT WINAPI cmd_with_params_SetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS uparams,
1749         const DB_UPARAMS ordinals[], const DBPARAMBINDINFO bindinfo[])
1750 {
1751     struct command *command = impl_from_ICommandWithParameters( iface );
1752     FIXME("%p, %Iu, %p, %p\n", command, uparams, ordinals, bindinfo);
1753     return E_NOTIMPL;
1754 }
1755
1756 struct ICommandWithParametersVtbl command_with_params_vtbl =
1757 {
1758     cmd_with_params_QueryInterface,
1759     cmd_with_params_AddRef,
1760     cmd_with_params_Release,
1761     cmd_with_params_GetParameterInfo,
1762     cmd_with_params_MapParameterNames,
1763     cmd_with_params_SetParameterInfo
1764 };
1765
1766 static HRESULT WINAPI createcommand_CreateCommand(IDBCreateCommand *iface, IUnknown *outer, REFIID riid,
1767                                             IUnknown **out)
1768 {
1769     struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
1770     struct command *command;
1771     HRESULT hr;
1772
1773     TRACE("%p, %p, %s, %p\n", session, outer, debugstr_guid(riid), out);
1774
1775     if (outer)
1776         FIXME("Outer not currently supported\n");
1777
1778     command = heap_alloc(sizeof(*command));
1779     if (!command)
1780         return E_OUTOFMEMORY;
1781
1782     command->ICommandText_iface.lpVtbl = &commandVtbl;
1783     command->ICommandProperties_iface.lpVtbl = &commonpropsVtbl;
1784     command->IColumnsInfo_iface.lpVtbl = &columninfoVtbl;
1785     command->IConvertType_iface.lpVtbl = &converttypeVtbl;
1786     command->ICommandPrepare_iface.lpVtbl = &commandprepareVtbl;
1787     command->ICommandWithParameters_iface.lpVtbl = &command_with_params_vtbl;
1788     command->refs = 1;
1789     command->query = NULL;
1790     command->hdbc = session->hdbc;
1791     command->hstmt = NULL;
1792
1793     command->prop_count = ARRAY_SIZE(msdasql_init_props);
1794     command->properties = heap_alloc(sizeof(msdasql_init_props));
1795     memcpy(command->properties, msdasql_init_props, sizeof(msdasql_init_props));
1796
1797     IUnknown_QueryInterface(&session->session_iface, &IID_IUnknown, (void**)&command->session);
1798
1799     hr = ICommandText_QueryInterface(&command->ICommandText_iface, riid, (void**)out);
1800     ICommandText_Release(&command->ICommandText_iface);
1801     return hr;
1802 }
1803
1804 static const IDBCreateCommandVtbl createcommandVtbl =
1805 {
1806     createcommand_QueryInterface,
1807     createcommand_AddRef,
1808     createcommand_Release,
1809     createcommand_CreateCommand
1810 };
1811
1812 static HRESULT WINAPI transjoin_QueryInterface(ITransactionJoin *iface, REFIID riid, void **out)
1813 {
1814     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1815     return IUnknown_QueryInterface(&session->session_iface, riid, out);
1816 }
1817
1818 static ULONG WINAPI transjoin_AddRef(ITransactionJoin *iface)
1819 {
1820     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1821     return IUnknown_AddRef(&session->session_iface);
1822 }
1823
1824 static ULONG WINAPI transjoin_Release(ITransactionJoin *iface)
1825 {
1826     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1827     return IUnknown_Release(&session->session_iface);
1828 }
1829
1830 static HRESULT WINAPI transjoin_GetOptionsObject(ITransactionJoin *iface, ITransactionOptions **options)
1831 {
1832     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1833
1834     FIXME("%p, %p\n", session, options);
1835
1836     return E_NOTIMPL;
1837 }
1838
1839 static HRESULT WINAPI transjoin_JoinTransaction(ITransactionJoin *iface, IUnknown *unk, ISOLEVEL level,
1840     ULONG flags, ITransactionOptions *options)
1841 {
1842     struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1843
1844     FIXME("%p, %p, %lu, 0x%08lx, %p\n", session, unk, level, flags, options);
1845
1846     return E_NOTIMPL;
1847 }
1848
1849 static const ITransactionJoinVtbl transactionjoinVtbl =
1850 {
1851     transjoin_QueryInterface,
1852     transjoin_AddRef,
1853     transjoin_Release,
1854     transjoin_GetOptionsObject,
1855     transjoin_JoinTransaction
1856 };
1857
1858 static HRESULT WINAPI transaction_QueryInterface(ITransaction *iface, REFIID riid, void **out)
1859 {
1860     struct msdasql_session *session = impl_from_ITransaction( iface );
1861     return IUnknown_QueryInterface(&session->session_iface, riid, out);
1862 }
1863
1864 static ULONG WINAPI transaction_AddRef(ITransaction *iface)
1865 {
1866     struct msdasql_session *session = impl_from_ITransaction( iface );
1867     return IUnknown_AddRef(&session->session_iface);
1868 }
1869
1870 static ULONG WINAPI transaction_Release(ITransaction *iface)
1871 {
1872     struct msdasql_session *session = impl_from_ITransaction( iface );
1873     return IUnknown_Release(&session->session_iface);
1874 }
1875
1876 static HRESULT WINAPI transaction_Commit(ITransaction *iface, BOOL retaining, DWORD tc, DWORD rm)
1877 {
1878     struct msdasql_session *session = impl_from_ITransaction( iface );
1879
1880     FIXME("%p, %d, %ld, %ld\n", session, retaining, tc, rm);
1881
1882     return E_NOTIMPL;
1883 }
1884
1885 static HRESULT WINAPI transaction_Abort(ITransaction *iface, BOID *reason, BOOL retaining, BOOL async)
1886 {
1887     struct msdasql_session *session = impl_from_ITransaction( iface );
1888
1889     FIXME("%p, %p, %d, %d\n", session, reason, retaining, async);
1890
1891     return E_NOTIMPL;
1892 }
1893
1894 static HRESULT WINAPI transaction_GetTransactionInfo(ITransaction *iface, XACTTRANSINFO *info)
1895 {
1896     struct msdasql_session *session = impl_from_ITransaction( iface );
1897
1898     FIXME("%p, %p\n", session, info);
1899
1900     return E_NOTIMPL;
1901 }
1902
1903 static const ITransactionVtbl transactionVtbl =
1904 {
1905     transaction_QueryInterface,
1906     transaction_AddRef,
1907     transaction_Release,
1908     transaction_Commit,
1909     transaction_Abort,
1910     transaction_GetTransactionInfo
1911 };
1912
1913 HRESULT create_db_session(REFIID riid, IUnknown *datasource, HDBC hdbc, void **unk)
1914 {
1915     struct msdasql_session *session;
1916     HRESULT hr;
1917
1918     session = heap_alloc(sizeof(*session));
1919     if (!session)
1920         return E_OUTOFMEMORY;
1921
1922     session->session_iface.lpVtbl = &unkfactoryVtbl;
1923     session->IGetDataSource_iface.lpVtbl = &datasourceVtbl;
1924     session->IOpenRowset_iface.lpVtbl = &openrowsetVtbl;
1925     session->ISessionProperties_iface.lpVtbl = &propertiesVtbl;
1926     session->IDBCreateCommand_iface.lpVtbl = &createcommandVtbl;
1927     session->ITransactionJoin_iface.lpVtbl = &transactionjoinVtbl;
1928     session->ITransaction_iface.lpVtbl = &transactionVtbl;
1929
1930     IUnknown_QueryInterface(datasource, &IID_IUnknown, (void**)&session->datasource);
1931     session->refs = 1;
1932     session->hdbc = hdbc;
1933
1934     hr = IUnknown_QueryInterface(&session->session_iface, riid, unk);
1935     IUnknown_Release(&session->session_iface);
1936     return hr;
1937 }