?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msdasql: Use SQLColAttributesW to fetch statement attributes.
[wine.git] / dlls / msdasql / session.c
blob588be365b72fc2525bd4a657205929d75d8624db
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 if (command->properties)
697 heap_free(command->properties);
698 if (command->session)
699 IUnknown_Release(command->session);
700
701 if (command->hstmt)
702 SQLFreeHandle(SQL_HANDLE_STMT, command->hstmt);
703
704 heap_free( command->query );
705 heap_free( command );
706 }
707 return refs;
708 }
709
710 static HRESULT WINAPI command_Cancel(ICommandText *iface)
711 {
712 struct command *command = impl_from_ICommandText( iface );
713 FIXME("%p\n", command);
714 return E_NOTIMPL;
715 }
716
717 struct msdasql_rowset
718 {
719 IRowset IRowset_iface;
720 IRowsetInfo IRowsetInfo_iface;
721 IColumnsInfo IColumnsInfo_iface;
722 IAccessor IAccessor_iface;
723 IColumnsRowset IColumnsRowset_iface;
724 IUnknown *caller;
725 LONG refs;
726 SQLHSTMT hstmt;
727 };
728
729 static inline struct msdasql_rowset *impl_from_IRowset( IRowset *iface )
730 {
731 return CONTAINING_RECORD( iface, struct msdasql_rowset, IRowset_iface );
732 }
733
734 static inline struct msdasql_rowset *impl_from_IRowsetInfo( IRowsetInfo *iface )
735 {
736 return CONTAINING_RECORD( iface, struct msdasql_rowset, IRowsetInfo_iface );
737 }
738
739 static inline struct msdasql_rowset *rowset_impl_from_IColumnsInfo( IColumnsInfo *iface )
740 {
741 return CONTAINING_RECORD( iface, struct msdasql_rowset, IColumnsInfo_iface );
742 }
743
744 static inline struct msdasql_rowset *impl_from_IAccessor ( IAccessor *iface )
745 {
746 return CONTAINING_RECORD( iface, struct msdasql_rowset, IAccessor_iface );
747 }
748
749 static inline struct msdasql_rowset *impl_from_IColumnsRowset ( IColumnsRowset *iface )
750 {
751 return CONTAINING_RECORD( iface, struct msdasql_rowset, IColumnsRowset_iface );
752 }
753
754 static HRESULT WINAPI msdasql_rowset_QueryInterface(IRowset *iface, REFIID riid, void **ppv)
755 {
756 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
757
758 TRACE( "%p, %s, %p\n", rowset, debugstr_guid(riid), ppv );
759
760 *ppv = NULL;
761 if(IsEqualGUID(&IID_IUnknown, riid) ||
762 IsEqualGUID(&IID_IRowset, riid))
763 {
764 *ppv = &rowset->IRowset_iface;
765 }
766 else if (IsEqualGUID(&IID_IRowsetInfo, riid))
767 {
768 *ppv = &rowset->IRowsetInfo_iface;
769 }
770 else if (IsEqualGUID(&IID_IColumnsInfo, riid))
771 {
772 *ppv = &rowset->IColumnsInfo_iface;
773 }
774 else if(IsEqualGUID(&IID_IAccessor, riid))
775 {
776 *ppv = &rowset->IAccessor_iface;
777 }
778 else if(IsEqualGUID(&IID_IColumnsRowset, riid))
779 {
780 *ppv = &rowset->IColumnsRowset_iface;
781 }
782 else if (IsEqualGUID(&IID_IRowsetChange, riid))
783 {
784 TRACE("IID_IRowsetChange not supported\n");
785 return E_NOINTERFACE;
786 }
787 else if (IsEqualGUID(&IID_IRowsetUpdate, riid))
788 {
789 TRACE("IID_IRowsetUpdate not supported\n");
790 return E_NOINTERFACE;
791 }
792 else if (IsEqualGUID(&IID_IRowsetLocate, riid))
793 {
794 TRACE("IID_IRowsetLocate not supported\n");
795 return E_NOINTERFACE;
796 }
797
798 if(*ppv)
799 {
800 IUnknown_AddRef((IUnknown*)*ppv);
801 return S_OK;
802 }
803
804 FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
805 return E_NOINTERFACE;
806 }
807
808 static ULONG WINAPI msdasql_rowset_AddRef(IRowset *iface)
809 {
810 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
811 LONG refs = InterlockedIncrement( &rowset->refs );
812 TRACE( "%p new refcount %ld\n", rowset, refs );
813 return refs;
814 }
815
816 static ULONG WINAPI msdasql_rowset_Release(IRowset *iface)
817 {
818 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
819 LONG refs = InterlockedDecrement( &rowset->refs );
820 TRACE( "%p new refcount %ld\n", rowset, refs );
821 if (!refs)
822 {
823 TRACE( "destroying %p\n", rowset );
824
825 SQLFreeHandle(SQL_HANDLE_STMT, rowset->hstmt);
826
827 if (rowset->caller)
828 IUnknown_Release(rowset->caller);
829
830 heap_free( rowset );
831 }
832 return refs;
833 }
834
835 static HRESULT WINAPI msdasql_rowset_AddRefRows(IRowset *iface, DBCOUNTITEM count,
836 const HROW rows[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
837 {
838 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
839 FIXME("%p, %Id, %p, %p, %p\n", rowset, count, rows, ref_counts, status);
840 return E_NOTIMPL;
841 }
842
843 static HRESULT WINAPI msdasql_rowset_GetData(IRowset *iface, HROW row, HACCESSOR accessor, void *data)
844 {
845 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
846 FIXME("%p, %Id, %Id, %p\n", rowset, row, accessor, data);
847 return E_NOTIMPL;
848 }
849
850 static HRESULT WINAPI msdasql_rowset_GetNextRows(IRowset *iface, HCHAPTER reserved, DBROWOFFSET offset,
851 DBROWCOUNT count, DBCOUNTITEM *obtained, HROW **rows)
852 {
853 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
854 FIXME("%p, %Id, %Id, %Id, %p, %p\n", rowset, reserved, offset, count, obtained, rows);
855 return E_NOTIMPL;
856 }
857
858 static HRESULT WINAPI msdasql_rowset_ReleaseRows(IRowset *iface, DBCOUNTITEM count,
859 const HROW rows[], DBROWOPTIONS options[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
860 {
861 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
862
863 FIXME("%p, %Id, %p, %p, %p, %p\n", rowset, count, rows, options, ref_counts, status);
864 return E_NOTIMPL;
865 }
866
867 static HRESULT WINAPI msdasql_rowset_RestartPosition(IRowset *iface, HCHAPTER reserved)
868 {
869 struct msdasql_rowset *rowset = impl_from_IRowset( iface );
870 FIXME("%p, %Id\n", rowset, reserved);
871 return E_NOTIMPL;
872 }
873
874 static const struct IRowsetVtbl msdasql_rowset_vtbl =
875 {
876 msdasql_rowset_QueryInterface,
877 msdasql_rowset_AddRef,
878 msdasql_rowset_Release,
879 msdasql_rowset_AddRefRows,
880 msdasql_rowset_GetData,
881 msdasql_rowset_GetNextRows,
882 msdasql_rowset_ReleaseRows,
883 msdasql_rowset_RestartPosition
884 };
885
886 static HRESULT WINAPI rowset_info_QueryInterface(IRowsetInfo *iface, REFIID riid, void **ppv)
887 {
888 struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
889 return IRowset_QueryInterface(&rowset->IRowset_iface, riid, ppv);
890 }
891
892 static ULONG WINAPI rowset_info_AddRef(IRowsetInfo *iface)
893 {
894 struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
895 return IRowset_AddRef(&rowset->IRowset_iface);
896 }
897
898 static ULONG WINAPI rowset_info_Release(IRowsetInfo *iface)
899 {
900 struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
901 return IRowset_Release(&rowset->IRowset_iface);
902 }
903
904 static HRESULT WINAPI rowset_info_GetProperties(IRowsetInfo *iface, const ULONG count,
905 const DBPROPIDSET propertyidsets[], ULONG *out_count, DBPROPSET **propertysets)
906 {
907 struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
908 HRESULT hr;
909 ICommandProperties *props;
910
911 TRACE("%p, %lu, %p, %p, %p\n", rowset, count, propertyidsets, out_count, propertysets);
912
913 hr = IUnknown_QueryInterface(rowset->caller, &IID_ICommandProperties, (void**)&props);
914 if (FAILED(hr))
915 return hr;
916
917 hr = ICommandProperties_GetProperties(props, count, propertyidsets, out_count, propertysets);
918 ICommandProperties_Release(props);
919
920 return hr;
921 }
922
923 static HRESULT WINAPI rowset_info_GetReferencedRowset(IRowsetInfo *iface, DBORDINAL ordinal,
924 REFIID riid, IUnknown **unk)
925 {
926 struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
927 FIXME("%p, %Id, %s, %p\n", rowset, ordinal, debugstr_guid(riid), unk);
928 return E_NOTIMPL;
929 }
930
931 static HRESULT WINAPI rowset_info_GetSpecification(IRowsetInfo *iface, REFIID riid,
932 IUnknown **specification)
933 {
934 struct msdasql_rowset *rowset = impl_from_IRowsetInfo( iface );
935
936 TRACE("%p, %s, %p\n", rowset, debugstr_guid(riid), specification);
937
938 if (!specification)
939 return E_INVALIDARG;
940
941 if (!rowset->caller)
942 return S_FALSE;
943
944 return IUnknown_QueryInterface(rowset->caller, riid, (void**)specification);
945 }
946
947 struct IRowsetInfoVtbl rowset_info_vtbl =
948 {
949 rowset_info_QueryInterface,
950 rowset_info_AddRef,
951 rowset_info_Release,
952 rowset_info_GetProperties,
953 rowset_info_GetReferencedRowset,
954 rowset_info_GetSpecification
955 };
956
957 static HRESULT WINAPI rowset_colsinfo_QueryInterface(IColumnsInfo *iface, REFIID riid, void **out)
958 {
959 struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
960 return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
961 }
962
963 static ULONG WINAPI rowset_colsinfo_AddRef(IColumnsInfo *iface)
964 {
965 struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
966 return IRowset_AddRef(&rowset->IRowset_iface);
967 }
968
969 static ULONG WINAPI rowset_colsinfo_Release(IColumnsInfo *iface)
970 {
971 struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
972 return IRowset_Release(&rowset->IRowset_iface);
973 }
974
975 static HRESULT WINAPI rowset_colsinfo_GetColumnInfo(IColumnsInfo *iface, DBORDINAL *columns,
976 DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
977 {
978 #define MAX_COLUMN_LEN 128
979
980 struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
981 DBCOLUMNINFO *dbcolumn;
982 RETCODE ret;
983 SQLSMALLINT colcnt;
984 int i;
985 OLECHAR *ptr;
986
987 TRACE("%p, %p, %p, %p\n", rowset, columns, colinfo, stringsbuffer);
988
989 if (!columns || !colinfo || !stringsbuffer)
990 return E_INVALIDARG;
991
992 SQLNumResultCols(rowset->hstmt, &colcnt);
993 TRACE("SQLNumResultCols %d\n", colcnt);
994
995 *columns = colcnt;
996
997 ptr = *stringsbuffer = CoTaskMemAlloc(colcnt * MAX_COLUMN_LEN * sizeof(WCHAR));
998 if (!ptr)
999 return E_OUTOFMEMORY;
1000
1001 dbcolumn = CoTaskMemAlloc(colcnt * sizeof(DBCOLUMNINFO));
1002 if (!dbcolumn)
1003 {
1004 CoTaskMemFree(ptr);
1005 return E_OUTOFMEMORY;
1006 }
1007
1008 for (i = 0; i < colcnt; i++)
1009 {
1010 SQLWCHAR columnname[MAX_COLUMN_LEN];
1011 SQLSMALLINT ColumnNameLen;
1012 SQLSMALLINT ColumnDataType;
1013 SQLULEN ColumnDataSize;
1014 SQLSMALLINT ColumnDataDigits;
1015 SQLSMALLINT ColumnDataNullable;
1016
1017 ret = SQLDescribeColW(rowset->hstmt, i+1, columnname, MAX_COLUMN_LEN, &ColumnNameLen, &ColumnDataType,
1018 &ColumnDataSize, &ColumnDataDigits, &ColumnDataNullable);
1019 if (SQL_SUCCEEDED(ret))
1020 {
1021 SQLLEN length;
1022
1023 TRACE("%d: Column Name : %s, Column Name Len : %i, SQL Data Type : %i, Data Size : %i, DecimalDigits : %i, Nullable %i\n",
1024 i, debugstr_w(columnname), (int)ColumnNameLen, (int)ColumnDataType, (int)ColumnDataSize, (int)ColumnDataDigits,
1025 (int)ColumnDataNullable);
1026 lstrcpyW(ptr, columnname);
1027
1028 dbcolumn[i].pwszName = ptr;
1029 dbcolumn[i].pTypeInfo = NULL;
1030 dbcolumn[i].iOrdinal = i+1;
1031
1032 ret = SQLColAttributesW (rowset->hstmt, i+1, SQL_DESC_UNSIGNED, NULL, 0, NULL, &length);
1033 if (!SQL_SUCCEEDED(ret))
1034 {
1035 dump_sql_diag_records(SQL_HANDLE_STMT, rowset->hstmt);
1036 CoTaskMemFree(ptr);
1037 CoTaskMemFree(dbcolumn);
1038 ERR("Failed to get column %d attribute\n", i+1);
1039 return E_FAIL;
1040 }
1041
1042 dbcolumn[i].wType = sqltype_to_bindtype(ColumnDataType, length == SQL_FALSE);
1043 TRACE("SQLType %s -> %s\n", debugstr_sqltype(ColumnDataType), debugstr_dbtype(dbcolumn[i].wType));
1044
1045 dbcolumn[i].dwFlags = DBCOLUMNFLAGS_WRITE;
1046
1047 ret = SQLColAttributesW(rowset->hstmt, i+1, SQL_DESC_LENGTH, NULL, 0, NULL, &length);
1048 if (!SQL_SUCCEEDED(ret))
1049 {
1050 CoTaskMemFree(ptr);
1051 CoTaskMemFree(dbcolumn);
1052 ERR("Failed to get column %d length (%d)\n", i+1, ret);
1053 return E_FAIL;
1054 }
1055 dbcolumn[i].ulColumnSize = length;
1056
1057 if (dbcolumn[i].ulColumnSize > 1024 && is_variable_length(ColumnDataType))
1058 dbcolumn[i].dwFlags |= DBCOLUMNFLAGS_MAYDEFER | DBCOLUMNFLAGS_ISLONG;
1059
1060 if (ColumnDataNullable)
1061 dbcolumn[i].dwFlags |= DBCOLUMNFLAGS_ISNULLABLE | DBCOLUMNFLAGS_MAYBENULL;
1062
1063 if (is_fixed_length(ColumnDataType))
1064 dbcolumn[i].dwFlags |= DBCOLUMNFLAGS_ISFIXEDLENGTH;
1065
1066 ret = SQLColAttributesW(rowset->hstmt, i+1, SQL_DESC_SCALE, NULL, 0, NULL, &length);
1067 if (!SQL_SUCCEEDED(ret))
1068 {
1069 CoTaskMemFree(ptr);
1070 CoTaskMemFree(dbcolumn);
1071 ERR("Failed to get column %d scale (%d)\n", i+1, ret);
1072 return E_FAIL;
1073 }
1074 if (length == 0)
1075 length = 255;
1076 dbcolumn[i].bScale = length;
1077
1078 ret = SQLColAttributesW(rowset->hstmt, i+1, SQL_DESC_PRECISION, NULL, 0, NULL, &length);
1079 if (!SQL_SUCCEEDED(ret))
1080 {
1081 CoTaskMemFree(ptr);
1082 CoTaskMemFree(dbcolumn);
1083 ERR("Failed to get column %d precision (%d)\n", i+1, ret);
1084 return E_FAIL;
1085 }
1086 if (length == 0)
1087 length = 255;
1088 dbcolumn[i].bPrecision= length;
1089
1090 dbcolumn[i].columnid.eKind = DBKIND_NAME;
1091 dbcolumn[i].columnid.uName.pwszName = ptr;
1092
1093 ptr += ColumnNameLen + 1;
1094 }
1095 else
1096 {
1097 CoTaskMemFree(ptr);
1098 CoTaskMemFree(dbcolumn);
1099 ERR("Failed to get column %d description (%d)\n", i+1, ret);
1100 return E_FAIL;
1101 }
1102 }
1103
1104 *colinfo = dbcolumn;
1105 #undef MAX_COLUMN_LEN
1106 return S_OK;
1107 }
1108
1109 static HRESULT WINAPI rowset_colsinfo_MapColumnIDs(IColumnsInfo *iface, DBORDINAL column_ids,
1110 const DBID *dbids, DBORDINAL *columns)
1111 {
1112 struct msdasql_rowset *rowset = rowset_impl_from_IColumnsInfo( iface );
1113 FIXME("%p, %Id, %p, %p\n", rowset, column_ids, dbids, columns);
1114 return E_NOTIMPL;
1115 }
1116
1117 static struct IColumnsInfoVtbl rowset_columninfo_vtbll =
1118 {
1119 rowset_colsinfo_QueryInterface,
1120 rowset_colsinfo_AddRef,
1121 rowset_colsinfo_Release,
1122 rowset_colsinfo_GetColumnInfo,
1123 rowset_colsinfo_MapColumnIDs
1124 };
1125
1126 static HRESULT WINAPI rowset_accessor_QueryInterface(IAccessor *iface, REFIID riid, void **out)
1127 {
1128 struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1129 return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
1130 }
1131
1132 static ULONG WINAPI rowset_accessor_AddRef(IAccessor *iface)
1133 {
1134 struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1135 return IRowset_AddRef(&rowset->IRowset_iface);
1136 }
1137
1138 static ULONG WINAPI rowset_accessor_Release(IAccessor *iface)
1139 {
1140 struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1141 return IRowset_Release(&rowset->IRowset_iface);
1142 }
1143
1144 static HRESULT WINAPI rowset_accessor_AddRefAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
1145 {
1146 struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1147 FIXME("%p, %Id, %p\n", rowset, accessor, count);
1148 return E_NOTIMPL;
1149 }
1150
1151 static HRESULT WINAPI rowset_accessor_CreateAccessor(IAccessor *iface, DBACCESSORFLAGS flags,
1152 DBCOUNTITEM count, const DBBINDING bindings[], DBLENGTH row_size, HACCESSOR *accessor,
1153 DBBINDSTATUS status[])
1154 {
1155 struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1156 FIXME("%p, 0x%08lx, %Id, %p, %Id, %p, %p\n", rowset, flags, count, bindings, row_size, accessor, status);
1157 return E_NOTIMPL;
1158 }
1159
1160 static HRESULT WINAPI rowset_accessor_GetBindings(IAccessor *iface, HACCESSOR accessor,
1161 DBACCESSORFLAGS *flags, DBCOUNTITEM *count, DBBINDING **bindings)
1162 {
1163 struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1164 FIXME("%p, %Id, %p, %p, %p\n", rowset, accessor, flags, count, bindings);
1165 return E_NOTIMPL;
1166 }
1167
1168 static HRESULT WINAPI rowset_accessor_ReleaseAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
1169 {
1170 struct msdasql_rowset *rowset = impl_from_IAccessor( iface );
1171 FIXME("%p, %Id, %p\n", rowset, accessor, count);
1172 return E_NOTIMPL;
1173 }
1174
1175 struct IAccessorVtbl accessor_vtbl =
1176 {
1177 rowset_accessor_QueryInterface,
1178 rowset_accessor_AddRef,
1179 rowset_accessor_Release,
1180 rowset_accessor_AddRefAccessor,
1181 rowset_accessor_CreateAccessor,
1182 rowset_accessor_GetBindings,
1183 rowset_accessor_ReleaseAccessor
1184 };
1185
1186 static HRESULT WINAPI column_rs_QueryInterface(IColumnsRowset *iface, REFIID riid, void **out)
1187 {
1188 struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1189 return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
1190 }
1191
1192 static ULONG WINAPI column_rs_AddRef(IColumnsRowset *iface)
1193 {
1194 struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1195 return IRowset_AddRef(&rowset->IRowset_iface);
1196 }
1197
1198 static ULONG WINAPI column_rs_Release(IColumnsRowset *iface)
1199 {
1200 struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1201 return IRowset_Release(&rowset->IRowset_iface);
1202 }
1203
1204 static HRESULT WINAPI column_rs_GetAvailableColumns(IColumnsRowset *iface, DBORDINAL *count, DBID **columns)
1205 {
1206 struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1207
1208 TRACE("%p, %p, %p\n", rowset, count, columns);
1209
1210 if (!count || !columns)
1211 return E_INVALIDARG;
1212
1213 *count = 0;
1214 *columns = NULL;
1215
1216 return S_OK;
1217 }
1218
1219 static HRESULT WINAPI column_rs_GetColumnsRowset(IColumnsRowset *iface, IUnknown *outer, DBORDINAL count,
1220 const DBID columns[], REFIID riid, ULONG property_cnt, DBPROPSET property_sets[], IUnknown **unk_rs)
1221 {
1222 struct msdasql_rowset *rowset = impl_from_IColumnsRowset( iface );
1223 FIXME("(%p)->(%p, %Id, %p, %s, %lu, %p, %p): stub\n", rowset, outer, count, columns, debugstr_guid(riid),
1224 property_cnt, property_sets, unk_rs);
1225 return E_NOTIMPL;
1226 }
1227
1228 struct IColumnsRowsetVtbl columnrs_rs_vtbl =
1229 {
1230 column_rs_QueryInterface,
1231 column_rs_AddRef,
1232 column_rs_Release,
1233 column_rs_GetAvailableColumns,
1234 column_rs_GetColumnsRowset
1235 };
1236
1237 static HRESULT WINAPI command_Execute(ICommandText *iface, IUnknown *outer, REFIID riid,
1238 DBPARAMS *params, DBROWCOUNT *affected, IUnknown **rowset)
1239 {
1240 struct command *command = impl_from_ICommandText( iface );
1241 struct msdasql_rowset *msrowset;
1242 HRESULT hr = S_OK;
1243 RETCODE ret;
1244 SQLHSTMT hstmt = command->hstmt;
1245 SQLLEN results = -1;
1246 BOOL free_hstmt = TRUE;
1247
1248 TRACE("%p, %p, %s, %p %p %p\n", command, outer, debugstr_guid(riid), params, affected, rowset);
1249
1250 if (!hstmt)
1251 SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &hstmt);
1252
1253 ret = SQLExecDirectW(hstmt, command->query, SQL_NTS);
1254 if (ret != SQL_SUCCESS)
1255 {
1256 dump_sql_diag_records(SQL_HANDLE_STMT, hstmt);
1257 return E_FAIL;
1258 }
1259
1260 *rowset = NULL;
1261 if (!wcsnicmp( command->query, L"select ", 7 ))
1262 {
1263 msrowset = heap_alloc(sizeof(*msrowset));
1264 if (!msrowset)
1265 return E_OUTOFMEMORY;
1266
1267 command->hstmt = NULL;
1268
1269 msrowset->IRowset_iface.lpVtbl = &msdasql_rowset_vtbl;
1270 msrowset->IRowsetInfo_iface.lpVtbl = &rowset_info_vtbl;
1271 msrowset->IColumnsInfo_iface.lpVtbl = &rowset_columninfo_vtbll;
1272 msrowset->IAccessor_iface.lpVtbl = &accessor_vtbl;
1273 msrowset->IColumnsRowset_iface.lpVtbl = &columnrs_rs_vtbl;
1274 msrowset->refs = 1;
1275 ICommandText_QueryInterface(iface, &IID_IUnknown, (void**)&msrowset->caller);
1276 msrowset->hstmt = hstmt;
1277 free_hstmt = FALSE;
1278
1279 hr = IRowset_QueryInterface(&msrowset->IRowset_iface, riid, (void**)rowset);
1280 IRowset_Release(&msrowset->IRowset_iface);
1281 }
1282
1283 if (affected)
1284 {
1285 ret = SQLRowCount(hstmt, &results);
1286 if (ret != SQL_SUCCESS)
1287 ERR("SQLRowCount failed (%d)\n", ret);
1288
1289 *affected = results;
1290 }
1291
1292 if (free_hstmt)
1293 SQLFreeStmt(hstmt, SQL_CLOSE);
1294
1295 return hr;
1296 }
1297
1298 static HRESULT WINAPI command_GetDBSession(ICommandText *iface, REFIID riid, IUnknown **session)
1299 {
1300 struct command *command = impl_from_ICommandText( iface );
1301
1302 TRACE("%p, %s, %p\n", command, debugstr_guid(riid), session);
1303
1304 if (!session)
1305 return E_INVALIDARG;
1306
1307 *session = NULL;
1308
1309 if (!command->session)
1310 return S_FALSE;
1311
1312 return IUnknown_QueryInterface(command->session, riid, (void**)session);
1313 }
1314
1315 static HRESULT WINAPI command_GetCommandText(ICommandText *iface, GUID *dialect, LPOLESTR *commandstr)
1316 {
1317 struct command *command = impl_from_ICommandText( iface );
1318 HRESULT hr = S_OK;
1319 TRACE("%p, %p, %p\n", command, dialect, commandstr);
1320
1321 if (!command->query)
1322 return DB_E_NOCOMMAND;
1323
1324 if (dialect && !IsEqualGUID(&DBGUID_DEFAULT, dialect))
1325 {
1326 *dialect = DBGUID_DEFAULT;
1327 hr = DB_S_DIALECTIGNORED;
1328 }
1329
1330 *commandstr = heap_alloc((lstrlenW(command->query)+1)*sizeof(WCHAR));
1331 wcscpy(*commandstr, command->query);
1332 return hr;
1333 }
1334
1335 static HRESULT WINAPI command_SetCommandText(ICommandText *iface, REFGUID dialect, LPCOLESTR commandstr)
1336 {
1337 struct command *command = impl_from_ICommandText( iface );
1338 TRACE("%p, %s, %s\n", command, debugstr_guid(dialect), debugstr_w(commandstr));
1339
1340 if (!IsEqualGUID(&DBGUID_DEFAULT, dialect))
1341 FIXME("Currently non Default Dialect isn't supported\n");
1342
1343 heap_free(command->query);
1344
1345 if (commandstr)
1346 {
1347 command->query = heap_alloc((lstrlenW(commandstr)+1)*sizeof(WCHAR));
1348 if (!command->query)
1349 return E_OUTOFMEMORY;
1350
1351 wcscpy(command->query, commandstr);
1352 }
1353 else
1354 command->query = NULL;
1355 return S_OK;
1356 }
1357
1358 static const ICommandTextVtbl commandVtbl =
1359 {
1360 command_QueryInterface,
1361 command_AddRef,
1362 command_Release,
1363 command_Cancel,
1364 command_Execute,
1365 command_GetDBSession,
1366 command_GetCommandText,
1367 command_SetCommandText
1368 };
1369
1370 static HRESULT WINAPI command_prop_QueryInterface(ICommandProperties *iface, REFIID riid, void **out)
1371 {
1372 struct command *command = impl_from_ICommandProperties( iface );
1373 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1374 }
1375
1376 static ULONG WINAPI command_prop_AddRef(ICommandProperties *iface)
1377 {
1378 struct command *command = impl_from_ICommandProperties( iface );
1379 return ICommandText_AddRef(&command->ICommandText_iface);
1380 }
1381
1382 static ULONG WINAPI command_prop_Release(ICommandProperties *iface)
1383 {
1384 struct command *command = impl_from_ICommandProperties( iface );
1385 return ICommandText_Release(&command->ICommandText_iface);
1386 }
1387
1388 static ULONG get_property_count(DWORD flag, struct msdasql_prop *properties, int prop_count)
1389 {
1390 int i, count = 0;
1391
1392 for(i=0; i < prop_count; i++)
1393 {
1394 if (properties[i].flags & flag)
1395 count++;
1396 }
1397
1398 return count;
1399 }
1400
1401 static HRESULT WINAPI command_prop_GetProperties(ICommandProperties *iface, ULONG count,
1402 const DBPROPIDSET propertyidsets[], ULONG *sets_cnt, DBPROPSET **propertyset)
1403 {
1404 struct command *command = impl_from_ICommandProperties( iface );
1405 DBPROPSET *propset = NULL;
1406 int i, j, k;
1407
1408 TRACE("%p %ld %p %p %p\n", command, count, propertyidsets, sets_cnt, propertyset);
1409
1410 /* All Properties */
1411 if (count == 0)
1412 {
1413 int idx;
1414 propset = CoTaskMemAlloc(2 * sizeof(DBPROPSET));
1415 if (!propset)
1416 return E_OUTOFMEMORY;
1417
1418 propset[0].guidPropertySet = DBPROPSET_ROWSET;
1419 propset[0].cProperties = get_property_count(DBPROPFLAGS_ROWSET, command->properties, command->prop_count);
1420 propset[0].rgProperties = CoTaskMemAlloc(propset[0].cProperties * sizeof(DBPROP));
1421 if (!propset[0].rgProperties)
1422 {
1423 CoTaskMemFree(propset);
1424 return E_OUTOFMEMORY;
1425 }
1426
1427 idx = 0;
1428 for (j=0; j < command->prop_count; j++)
1429 {
1430 if (!(command->properties[j].flags & DBPROPFLAGS_ROWSET))
1431 continue;
1432 propset[0].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1433
1434 V_VT(&propset[0].rgProperties[idx].vValue) = command->properties[j].vartype;
1435 if (command->properties[j].vartype == VT_BOOL)
1436 {
1437 V_BOOL(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1438 }
1439 else if (command->properties[j].vartype == VT_I4)
1440 {
1441 V_I4(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1442 }
1443 else
1444 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1445
1446 idx++;
1447 }
1448
1449 propset[1].guidPropertySet = DBPROPSET_PROVIDERROWSET;
1450 propset[1].cProperties = get_property_count(DBPROPFLAGS_DATASOURCEINFO, command->properties, command->prop_count);
1451 propset[1].rgProperties = CoTaskMemAlloc(propset[1].cProperties * sizeof(DBPROP));
1452 if (!propset[1].rgProperties)
1453 {
1454 CoTaskMemFree(propset[0].rgProperties);
1455 CoTaskMemFree(propset);
1456 return E_OUTOFMEMORY;
1457 }
1458
1459 idx = 0;
1460 for (j=0; j < command->prop_count; j++)
1461 {
1462 if (!(command->properties[j].flags & DBPROPFLAGS_DATASOURCEINFO))
1463 continue;
1464 propset[1].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1465
1466 V_VT(&propset[1].rgProperties[idx].vValue) = command->properties[j].vartype;
1467 if (command->properties[j].vartype == VT_BOOL)
1468 {
1469 V_BOOL(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1470 }
1471 else if (command->properties[j].vartype == VT_I4)
1472 {
1473 V_I4(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1474 }
1475 else
1476 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1477
1478 idx++;
1479 }
1480
1481 *sets_cnt = 2;
1482 }
1483 else
1484 {
1485 propset = CoTaskMemAlloc(count * sizeof(DBPROPSET));
1486 if (!propset)
1487 return E_OUTOFMEMORY;
1488
1489 for (i=0; i < count; i++)
1490 {
1491 TRACE("Property id %d (count %ld, set %s)\n", i, propertyidsets[i].cPropertyIDs,
1492 debugstr_guid(&propertyidsets[i].guidPropertySet));
1493
1494 propset[i].cProperties = propertyidsets[i].cPropertyIDs;
1495 propset[i].rgProperties = CoTaskMemAlloc(propset[i].cProperties * sizeof(DBPROP));
1496
1497 for (j=0; j < propset[i].cProperties; j++)
1498 {
1499 propset[i].rgProperties[j].dwPropertyID = propertyidsets[i].rgPropertyIDs[j];
1500
1501 for(k = 0; k < command->prop_count; k++)
1502 {
1503 if (command->properties[k].property_id == propertyidsets[i].rgPropertyIDs[j])
1504 {
1505 V_VT(&propset[i].rgProperties[i].vValue) = command->properties[j].vartype;
1506 if (command->properties[j].vartype == VT_BOOL)
1507 {
1508 V_BOOL(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1509 }
1510 else if (command->properties[j].vartype == VT_I4)
1511 {
1512 V_I4(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1513 }
1514 else
1515 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1516 break;
1517 }
1518 }
1519 }
1520 }
1521
1522 *sets_cnt = count;
1523 }
1524
1525 *propertyset = propset;
1526
1527 return S_OK;
1528 }
1529
1530 static HRESULT WINAPI command_prop_SetProperties(ICommandProperties *iface, ULONG count,
1531 DBPROPSET propertyset[])
1532 {
1533 struct command *command = impl_from_ICommandProperties( iface );
1534 int i, j, k;
1535
1536 TRACE("%p %lu, %p\n", command, count, propertyset);
1537
1538 for(i=0; i < count; i++)
1539 {
1540 TRACE("set %s, count %ld\n", debugstr_guid(&propertyset[i].guidPropertySet), propertyset[i].cProperties);
1541 for(j=0; j < propertyset[i].cProperties; j++)
1542 {
1543 for(k=0; k < command->prop_count; k++)
1544 {
1545 if (command->properties[k].property_id == propertyset[i].rgProperties[j].dwPropertyID)
1546 {
1547 TRACE("Found property 0x%08lx\n", command->properties[k].property_id);
1548 if (command->properties[k].flags & DBPROPFLAGS_WRITE)
1549 {
1550 if (command->properties[k].vartype == VT_BOOL)
1551 {
1552 command->properties[k].value = V_BOOL(&propertyset[i].rgProperties[j].vValue);
1553 }
1554 else if (command->properties[k].vartype == VT_I4)
1555 {
1556 command->properties[k].value = V_I4(&propertyset[i].rgProperties[j].vValue);
1557 }
1558 else
1559 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1560 }
1561 else
1562 WARN("Attempting to set Readonly property\n");
1563
1564 break;
1565 }
1566 }
1567 }
1568 }
1569 return S_OK;
1570 }
1571
1572 static const ICommandPropertiesVtbl commonpropsVtbl =
1573 {
1574 command_prop_QueryInterface,
1575 command_prop_AddRef,
1576 command_prop_Release,
1577 command_prop_GetProperties,
1578 command_prop_SetProperties
1579 };
1580
1581 static HRESULT WINAPI colsinfo_QueryInterface(IColumnsInfo *iface, REFIID riid, void **out)
1582 {
1583 struct command *command = impl_from_IColumnsInfo( iface );
1584 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1585 }
1586
1587 static ULONG WINAPI colsinfo_AddRef(IColumnsInfo *iface)
1588 {
1589 struct command *command = impl_from_IColumnsInfo( iface );
1590 return ICommandText_AddRef(&command->ICommandText_iface);
1591 }
1592
1593 static ULONG WINAPI colsinfo_Release(IColumnsInfo *iface)
1594 {
1595 struct command *command = impl_from_IColumnsInfo( iface );
1596 return ICommandText_Release(&command->ICommandText_iface);
1597 }
1598
1599 static HRESULT WINAPI colsinfo_GetColumnInfo(IColumnsInfo *iface, DBORDINAL *columns,
1600 DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
1601 {
1602 struct command *command = impl_from_IColumnsInfo( iface );
1603 FIXME("%p, %p, %p, %p\n", command, columns, colinfo, stringsbuffer);
1604 return E_NOTIMPL;
1605 }
1606
1607 static HRESULT WINAPI colsinfo_MapColumnIDs(IColumnsInfo *iface, DBORDINAL column_ids,
1608 const DBID *dbids, DBORDINAL *columns)
1609 {
1610 struct command *command = impl_from_IColumnsInfo( iface );
1611 FIXME("%p, %Iu, %p, %p\n", command, column_ids, dbids, columns);
1612 return E_NOTIMPL;
1613 }
1614
1615 static struct IColumnsInfoVtbl columninfoVtbl =
1616 {
1617 colsinfo_QueryInterface,
1618 colsinfo_AddRef,
1619 colsinfo_Release,
1620 colsinfo_GetColumnInfo,
1621 colsinfo_MapColumnIDs
1622 };
1623
1624 static HRESULT WINAPI converttype_QueryInterface(IConvertType *iface, REFIID riid, void **out)
1625 {
1626 struct command *command = impl_from_IConvertType( iface );
1627 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1628 }
1629
1630 static ULONG WINAPI converttype_AddRef(IConvertType *iface)
1631 {
1632 struct command *command = impl_from_IConvertType( iface );
1633 return ICommandText_AddRef(&command->ICommandText_iface);
1634 }
1635
1636 static ULONG WINAPI converttype_Release(IConvertType *iface)
1637 {
1638 struct command *command = impl_from_IConvertType( iface );
1639 return ICommandText_Release(&command->ICommandText_iface);
1640 }
1641
1642 static HRESULT WINAPI converttype_CanConvert(IConvertType *iface, DBTYPE from, DBTYPE to, DBCONVERTFLAGS flags)
1643 {
1644 struct command *command = impl_from_IConvertType( iface );
1645 FIXME("%p, %u, %d, 0x%08lx\n", command, from, to, flags);
1646 return E_NOTIMPL;
1647 }
1648
1649 static struct IConvertTypeVtbl converttypeVtbl =
1650 {
1651 converttype_QueryInterface,
1652 converttype_AddRef,
1653 converttype_Release,
1654 converttype_CanConvert
1655 };
1656
1657 static HRESULT WINAPI commandprepare_QueryInterface(ICommandPrepare *iface, REFIID riid, void **out)
1658 {
1659 struct command *command = impl_from_ICommandPrepare( iface );
1660 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1661 }
1662
1663 static ULONG WINAPI commandprepare_AddRef(ICommandPrepare *iface)
1664 {
1665 struct command *command = impl_from_ICommandPrepare( iface );
1666 return ICommandText_AddRef(&command->ICommandText_iface);
1667 }
1668
1669 static ULONG WINAPI commandprepare_Release(ICommandPrepare *iface)
1670 {
1671 struct command *command = impl_from_ICommandPrepare( iface );
1672 return ICommandText_Release(&command->ICommandText_iface);
1673 }
1674
1675 static HRESULT WINAPI commandprepare_Prepare(ICommandPrepare *iface, ULONG runs)
1676 {
1677 struct command *command = impl_from_ICommandPrepare( iface );
1678 RETCODE ret;
1679
1680 TRACE("%p, %lu\n", command, runs);
1681
1682 if (!command->query)
1683 return DB_E_NOCOMMAND;
1684
1685 if (command->hstmt)
1686 SQLFreeHandle(SQL_HANDLE_STMT, command->hstmt);
1687
1688 SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &command->hstmt);
1689
1690 ret = SQLPrepareW(command->hstmt, command->query, SQL_NTS);
1691 if (ret != SQL_SUCCESS)
1692 {
1693 dump_sql_diag_records(SQL_HANDLE_STMT, command->hstmt);
1694 return E_FAIL;
1695 }
1696 return S_OK;
1697 }
1698
1699 static HRESULT WINAPI commandprepare_Unprepare(ICommandPrepare *iface)
1700 {
1701 struct command *command = impl_from_ICommandPrepare( iface );
1702 TRACE("%p\n", command);
1703 return S_OK;
1704 }
1705
1706 struct ICommandPrepareVtbl commandprepareVtbl =
1707 {
1708 commandprepare_QueryInterface,
1709 commandprepare_AddRef,
1710 commandprepare_Release,
1711 commandprepare_Prepare,
1712 commandprepare_Unprepare
1713 };
1714
1715 static HRESULT WINAPI cmd_with_params_QueryInterface(ICommandWithParameters *iface, REFIID riid, void **out)
1716 {
1717 struct command *command = impl_from_ICommandWithParameters( iface );
1718 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1719 }
1720
1721 static ULONG WINAPI cmd_with_params_AddRef(ICommandWithParameters *iface)
1722 {
1723 struct command *command = impl_from_ICommandWithParameters( iface );
1724 return ICommandText_AddRef(&command->ICommandText_iface);
1725 }
1726
1727 static ULONG WINAPI cmd_with_params_Release(ICommandWithParameters *iface)
1728 {
1729 struct command *command = impl_from_ICommandWithParameters( iface );
1730 return ICommandText_Release(&command->ICommandText_iface);
1731 }
1732
1733 static HRESULT WINAPI cmd_with_params_GetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS *uparams,
1734 DBPARAMINFO **info, OLECHAR **buffer)
1735 {
1736 struct command *command = impl_from_ICommandWithParameters( iface );
1737 FIXME("%p, %p, %p, %p\n", command, uparams, info, buffer);
1738 return E_NOTIMPL;
1739 }
1740
1741 static HRESULT WINAPI cmd_with_params_MapParameterNames(ICommandWithParameters *iface, DB_UPARAMS uparams,
1742 LPCWSTR names[], DB_LPARAMS ordinals[])
1743 {
1744 struct command *command = impl_from_ICommandWithParameters( iface );
1745 FIXME("%p, %Iu, %p, %p\n", command, uparams, names, ordinals);
1746 return E_NOTIMPL;
1747 }
1748
1749 static HRESULT WINAPI cmd_with_params_SetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS uparams,
1750 const DB_UPARAMS ordinals[], const DBPARAMBINDINFO bindinfo[])
1751 {
1752 struct command *command = impl_from_ICommandWithParameters( iface );
1753 FIXME("%p, %Iu, %p, %p\n", command, uparams, ordinals, bindinfo);
1754 return E_NOTIMPL;
1755 }
1756
1757 struct ICommandWithParametersVtbl command_with_params_vtbl =
1758 {
1759 cmd_with_params_QueryInterface,
1760 cmd_with_params_AddRef,
1761 cmd_with_params_Release,
1762 cmd_with_params_GetParameterInfo,
1763 cmd_with_params_MapParameterNames,
1764 cmd_with_params_SetParameterInfo
1765 };
1766
1767 static HRESULT WINAPI createcommand_CreateCommand(IDBCreateCommand *iface, IUnknown *outer, REFIID riid,
1768 IUnknown **out)
1769 {
1770 struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
1771 struct command *command;
1772 HRESULT hr;
1773
1774 TRACE("%p, %p, %s, %p\n", session, outer, debugstr_guid(riid), out);
1775
1776 if (outer)
1777 FIXME("Outer not currently supported\n");
1778
1779 command = heap_alloc(sizeof(*command));
1780 if (!command)
1781 return E_OUTOFMEMORY;
1782
1783 command->ICommandText_iface.lpVtbl = &commandVtbl;
1784 command->ICommandProperties_iface.lpVtbl = &commonpropsVtbl;
1785 command->IColumnsInfo_iface.lpVtbl = &columninfoVtbl;
1786 command->IConvertType_iface.lpVtbl = &converttypeVtbl;
1787 command->ICommandPrepare_iface.lpVtbl = &commandprepareVtbl;
1788 command->ICommandWithParameters_iface.lpVtbl = &command_with_params_vtbl;
1789 command->refs = 1;
1790 command->query = NULL;
1791 command->hdbc = session->hdbc;
1792 command->hstmt = NULL;
1793
1794 command->prop_count = ARRAY_SIZE(msdasql_init_props);
1795 command->properties = heap_alloc(sizeof(msdasql_init_props));
1796 memcpy(command->properties, msdasql_init_props, sizeof(msdasql_init_props));
1797
1798 IUnknown_QueryInterface(&session->session_iface, &IID_IUnknown, (void**)&command->session);
1799
1800 hr = ICommandText_QueryInterface(&command->ICommandText_iface, riid, (void**)out);
1801 ICommandText_Release(&command->ICommandText_iface);
1802 return hr;
1803 }
1804
1805 static const IDBCreateCommandVtbl createcommandVtbl =
1806 {
1807 createcommand_QueryInterface,
1808 createcommand_AddRef,
1809 createcommand_Release,
1810 createcommand_CreateCommand
1811 };
1812
1813 static HRESULT WINAPI transjoin_QueryInterface(ITransactionJoin *iface, REFIID riid, void **out)
1814 {
1815 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1816 return IUnknown_QueryInterface(&session->session_iface, riid, out);
1817 }
1818
1819 static ULONG WINAPI transjoin_AddRef(ITransactionJoin *iface)
1820 {
1821 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1822 return IUnknown_AddRef(&session->session_iface);
1823 }
1824
1825 static ULONG WINAPI transjoin_Release(ITransactionJoin *iface)
1826 {
1827 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1828 return IUnknown_Release(&session->session_iface);
1829 }
1830
1831 static HRESULT WINAPI transjoin_GetOptionsObject(ITransactionJoin *iface, ITransactionOptions **options)
1832 {
1833 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1834
1835 FIXME("%p, %p\n", session, options);
1836
1837 return E_NOTIMPL;
1838 }
1839
1840 static HRESULT WINAPI transjoin_JoinTransaction(ITransactionJoin *iface, IUnknown *unk, ISOLEVEL level,
1841 ULONG flags, ITransactionOptions *options)
1842 {
1843 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1844
1845 FIXME("%p, %p, %lu, 0x%08lx, %p\n", session, unk, level, flags, options);
1846
1847 return E_NOTIMPL;
1848 }
1849
1850 static const ITransactionJoinVtbl transactionjoinVtbl =
1851 {
1852 transjoin_QueryInterface,
1853 transjoin_AddRef,
1854 transjoin_Release,
1855 transjoin_GetOptionsObject,
1856 transjoin_JoinTransaction
1857 };
1858
1859 static HRESULT WINAPI transaction_QueryInterface(ITransaction *iface, REFIID riid, void **out)
1860 {
1861 struct msdasql_session *session = impl_from_ITransaction( iface );
1862 return IUnknown_QueryInterface(&session->session_iface, riid, out);
1863 }
1864
1865 static ULONG WINAPI transaction_AddRef(ITransaction *iface)
1866 {
1867 struct msdasql_session *session = impl_from_ITransaction( iface );
1868 return IUnknown_AddRef(&session->session_iface);
1869 }
1870
1871 static ULONG WINAPI transaction_Release(ITransaction *iface)
1872 {
1873 struct msdasql_session *session = impl_from_ITransaction( iface );
1874 return IUnknown_Release(&session->session_iface);
1875 }
1876
1877 static HRESULT WINAPI transaction_Commit(ITransaction *iface, BOOL retaining, DWORD tc, DWORD rm)
1878 {
1879 struct msdasql_session *session = impl_from_ITransaction( iface );
1880
1881 FIXME("%p, %d, %ld, %ld\n", session, retaining, tc, rm);
1882
1883 return E_NOTIMPL;
1884 }
1885
1886 static HRESULT WINAPI transaction_Abort(ITransaction *iface, BOID *reason, BOOL retaining, BOOL async)
1887 {
1888 struct msdasql_session *session = impl_from_ITransaction( iface );
1889
1890 FIXME("%p, %p, %d, %d\n", session, reason, retaining, async);
1891
1892 return E_NOTIMPL;
1893 }
1894
1895 static HRESULT WINAPI transaction_GetTransactionInfo(ITransaction *iface, XACTTRANSINFO *info)
1896 {
1897 struct msdasql_session *session = impl_from_ITransaction( iface );
1898
1899 FIXME("%p, %p\n", session, info);
1900
1901 return E_NOTIMPL;
1902 }
1903
1904 static const ITransactionVtbl transactionVtbl =
1905 {
1906 transaction_QueryInterface,
1907 transaction_AddRef,
1908 transaction_Release,
1909 transaction_Commit,
1910 transaction_Abort,
1911 transaction_GetTransactionInfo
1912 };
1913
1914 HRESULT create_db_session(REFIID riid, IUnknown *datasource, HDBC hdbc, void **unk)
1915 {
1916 struct msdasql_session *session;
1917 HRESULT hr;
1918
1919 session = heap_alloc(sizeof(*session));
1920 if (!session)
1921 return E_OUTOFMEMORY;
1922
1923 session->session_iface.lpVtbl = &unkfactoryVtbl;
1924 session->IGetDataSource_iface.lpVtbl = &datasourceVtbl;
1925 session->IOpenRowset_iface.lpVtbl = &openrowsetVtbl;
1926 session->ISessionProperties_iface.lpVtbl = &propertiesVtbl;
1927 session->IDBCreateCommand_iface.lpVtbl = &createcommandVtbl;
1928 session->ITransactionJoin_iface.lpVtbl = &transactionjoinVtbl;
1929 session->ITransaction_iface.lpVtbl = &transactionVtbl;
1930
1931 IUnknown_QueryInterface(datasource, &IID_IUnknown, (void**)&session->datasource);
1932 session->refs = 1;
1933 session->hdbc = hdbc;
1934
1935 hr = IUnknown_QueryInterface(&session->session_iface, riid, unk);
1936 IUnknown_Release(&session->session_iface);
1937 return hr;
1938 }
Windows API implementation