?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
localspl: Add unixname port extension.
[wine.git] / dlls / msdasql / session.c
blob67dc30bf09e5fe66feb6c46b97e22af77ec5dd3b
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 = SQLColAttribute(rowset->hstmt, i+1, SQL_DESC_UNSIGNED, NULL, 0, NULL, &length);
1033 if (!SQL_SUCCEEDED(ret))
1034 {
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 = SQLColAttribute(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 = SQLColAttribute(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 = SQLColAttribute(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
1246 TRACE("%p, %p, %s, %p %p %p\n", command, outer, debugstr_guid(riid), params, affected, rowset);
1247
1248 if (!hstmt)
1249 SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &hstmt);
1250
1251 ret = SQLExecDirectW(hstmt, command->query, SQL_NTS);
1252 if (ret != SQL_SUCCESS)
1253 {
1254 dump_sql_diag_records(SQL_HANDLE_STMT, hstmt);
1255 return E_FAIL;
1256 }
1257
1258 *rowset = NULL;
1259 if (!wcsnicmp( command->query, L"select ", 7 ))
1260 {
1261 msrowset = heap_alloc(sizeof(*msrowset));
1262 if (!msrowset)
1263 return E_OUTOFMEMORY;
1264
1265 command->hstmt = NULL;
1266
1267 msrowset->IRowset_iface.lpVtbl = &msdasql_rowset_vtbl;
1268 msrowset->IRowsetInfo_iface.lpVtbl = &rowset_info_vtbl;
1269 msrowset->IColumnsInfo_iface.lpVtbl = &rowset_columninfo_vtbll;
1270 msrowset->IAccessor_iface.lpVtbl = &accessor_vtbl;
1271 msrowset->IColumnsRowset_iface.lpVtbl = &columnrs_rs_vtbl;
1272 msrowset->refs = 1;
1273 ICommandText_QueryInterface(iface, &IID_IUnknown, (void**)&msrowset->caller);
1274 msrowset->hstmt = hstmt;
1275
1276 hr = IRowset_QueryInterface(&msrowset->IRowset_iface, riid, (void**)rowset);
1277 IRowset_Release(&msrowset->IRowset_iface);
1278 }
1279 else
1280 {
1281 ret = SQLRowCount(hstmt, &results);
1282 if (ret != SQL_SUCCESS)
1283 ERR("SQLRowCount failed (%d)\n", ret);
1284
1285 SQLFreeStmt(hstmt, SQL_CLOSE);
1286 }
1287
1288 if (affected)
1289 *affected = results;
1290
1291 return hr;
1292 }
1293
1294 static HRESULT WINAPI command_GetDBSession(ICommandText *iface, REFIID riid, IUnknown **session)
1295 {
1296 struct command *command = impl_from_ICommandText( iface );
1297
1298 TRACE("%p, %s, %p\n", command, debugstr_guid(riid), session);
1299
1300 if (!session)
1301 return E_INVALIDARG;
1302
1303 *session = NULL;
1304
1305 if (!command->session)
1306 return S_FALSE;
1307
1308 return IUnknown_QueryInterface(command->session, riid, (void**)session);
1309 }
1310
1311 static HRESULT WINAPI command_GetCommandText(ICommandText *iface, GUID *dialect, LPOLESTR *commandstr)
1312 {
1313 struct command *command = impl_from_ICommandText( iface );
1314 HRESULT hr = S_OK;
1315 TRACE("%p, %p, %p\n", command, dialect, commandstr);
1316
1317 if (!command->query)
1318 return DB_E_NOCOMMAND;
1319
1320 if (dialect && !IsEqualGUID(&DBGUID_DEFAULT, dialect))
1321 {
1322 *dialect = DBGUID_DEFAULT;
1323 hr = DB_S_DIALECTIGNORED;
1324 }
1325
1326 *commandstr = heap_alloc((lstrlenW(command->query)+1)*sizeof(WCHAR));
1327 wcscpy(*commandstr, command->query);
1328 return hr;
1329 }
1330
1331 static HRESULT WINAPI command_SetCommandText(ICommandText *iface, REFGUID dialect, LPCOLESTR commandstr)
1332 {
1333 struct command *command = impl_from_ICommandText( iface );
1334 TRACE("%p, %s, %s\n", command, debugstr_guid(dialect), debugstr_w(commandstr));
1335
1336 if (!IsEqualGUID(&DBGUID_DEFAULT, dialect))
1337 FIXME("Currently non Default Dialect isn't supported\n");
1338
1339 heap_free(command->query);
1340
1341 if (commandstr)
1342 {
1343 command->query = heap_alloc((lstrlenW(commandstr)+1)*sizeof(WCHAR));
1344 if (!command->query)
1345 return E_OUTOFMEMORY;
1346
1347 wcscpy(command->query, commandstr);
1348 }
1349 else
1350 command->query = NULL;
1351 return S_OK;
1352 }
1353
1354 static const ICommandTextVtbl commandVtbl =
1355 {
1356 command_QueryInterface,
1357 command_AddRef,
1358 command_Release,
1359 command_Cancel,
1360 command_Execute,
1361 command_GetDBSession,
1362 command_GetCommandText,
1363 command_SetCommandText
1364 };
1365
1366 static HRESULT WINAPI command_prop_QueryInterface(ICommandProperties *iface, REFIID riid, void **out)
1367 {
1368 struct command *command = impl_from_ICommandProperties( iface );
1369 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1370 }
1371
1372 static ULONG WINAPI command_prop_AddRef(ICommandProperties *iface)
1373 {
1374 struct command *command = impl_from_ICommandProperties( iface );
1375 return ICommandText_AddRef(&command->ICommandText_iface);
1376 }
1377
1378 static ULONG WINAPI command_prop_Release(ICommandProperties *iface)
1379 {
1380 struct command *command = impl_from_ICommandProperties( iface );
1381 return ICommandText_Release(&command->ICommandText_iface);
1382 }
1383
1384 static ULONG get_property_count(DWORD flag, struct msdasql_prop *properties, int prop_count)
1385 {
1386 int i, count = 0;
1387
1388 for(i=0; i < prop_count; i++)
1389 {
1390 if (properties[i].flags & flag)
1391 count++;
1392 }
1393
1394 return count;
1395 }
1396
1397 static HRESULT WINAPI command_prop_GetProperties(ICommandProperties *iface, ULONG count,
1398 const DBPROPIDSET propertyidsets[], ULONG *sets_cnt, DBPROPSET **propertyset)
1399 {
1400 struct command *command = impl_from_ICommandProperties( iface );
1401 DBPROPSET *propset = NULL;
1402 int i, j, k;
1403
1404 TRACE("%p %ld %p %p %p\n", command, count, propertyidsets, sets_cnt, propertyset);
1405
1406 /* All Properties */
1407 if (count == 0)
1408 {
1409 int idx;
1410 propset = CoTaskMemAlloc(2 * sizeof(DBPROPSET));
1411 if (!propset)
1412 return E_OUTOFMEMORY;
1413
1414 propset[0].guidPropertySet = DBPROPSET_ROWSET;
1415 propset[0].cProperties = get_property_count(DBPROPFLAGS_ROWSET, command->properties, command->prop_count);
1416 propset[0].rgProperties = CoTaskMemAlloc(propset[0].cProperties * sizeof(DBPROP));
1417 if (!propset[0].rgProperties)
1418 {
1419 CoTaskMemFree(propset);
1420 return E_OUTOFMEMORY;
1421 }
1422
1423 idx = 0;
1424 for (j=0; j < command->prop_count; j++)
1425 {
1426 if (!(command->properties[j].flags & DBPROPFLAGS_ROWSET))
1427 continue;
1428 propset[0].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1429
1430 V_VT(&propset[0].rgProperties[idx].vValue) = command->properties[j].vartype;
1431 if (command->properties[j].vartype == VT_BOOL)
1432 {
1433 V_BOOL(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1434 }
1435 else if (command->properties[j].vartype == VT_I4)
1436 {
1437 V_I4(&propset[0].rgProperties[idx].vValue) = command->properties[j].value;
1438 }
1439 else
1440 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1441
1442 idx++;
1443 }
1444
1445 propset[1].guidPropertySet = DBPROPSET_PROVIDERROWSET;
1446 propset[1].cProperties = get_property_count(DBPROPFLAGS_DATASOURCEINFO, command->properties, command->prop_count);
1447 propset[1].rgProperties = CoTaskMemAlloc(propset[1].cProperties * sizeof(DBPROP));
1448 if (!propset[1].rgProperties)
1449 {
1450 CoTaskMemFree(propset[0].rgProperties);
1451 CoTaskMemFree(propset);
1452 return E_OUTOFMEMORY;
1453 }
1454
1455 idx = 0;
1456 for (j=0; j < command->prop_count; j++)
1457 {
1458 if (!(command->properties[j].flags & DBPROPFLAGS_DATASOURCEINFO))
1459 continue;
1460 propset[1].rgProperties[idx].dwPropertyID = command->properties[j].property_id;
1461
1462 V_VT(&propset[1].rgProperties[idx].vValue) = command->properties[j].vartype;
1463 if (command->properties[j].vartype == VT_BOOL)
1464 {
1465 V_BOOL(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1466 }
1467 else if (command->properties[j].vartype == VT_I4)
1468 {
1469 V_I4(&propset[1].rgProperties[idx].vValue) = command->properties[j].value;
1470 }
1471 else
1472 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1473
1474 idx++;
1475 }
1476
1477 *sets_cnt = 2;
1478 }
1479 else
1480 {
1481 propset = CoTaskMemAlloc(count * sizeof(DBPROPSET));
1482 if (!propset)
1483 return E_OUTOFMEMORY;
1484
1485 for (i=0; i < count; i++)
1486 {
1487 TRACE("Property id %d (count %ld, set %s)\n", i, propertyidsets[i].cPropertyIDs,
1488 debugstr_guid(&propertyidsets[i].guidPropertySet));
1489
1490 propset[i].cProperties = propertyidsets[i].cPropertyIDs;
1491 propset[i].rgProperties = CoTaskMemAlloc(propset[i].cProperties * sizeof(DBPROP));
1492
1493 for (j=0; j < propset[i].cProperties; j++)
1494 {
1495 propset[i].rgProperties[j].dwPropertyID = propertyidsets[i].rgPropertyIDs[j];
1496
1497 for(k = 0; k < command->prop_count; k++)
1498 {
1499 if (command->properties[k].property_id == propertyidsets[i].rgPropertyIDs[j])
1500 {
1501 V_VT(&propset[i].rgProperties[i].vValue) = command->properties[j].vartype;
1502 if (command->properties[j].vartype == VT_BOOL)
1503 {
1504 V_BOOL(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1505 }
1506 else if (command->properties[j].vartype == VT_I4)
1507 {
1508 V_I4(&propset[i].rgProperties[i].vValue) = command->properties[j].value;
1509 }
1510 else
1511 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1512 break;
1513 }
1514 }
1515 }
1516 }
1517
1518 *sets_cnt = count;
1519 }
1520
1521 *propertyset = propset;
1522
1523 return S_OK;
1524 }
1525
1526 static HRESULT WINAPI command_prop_SetProperties(ICommandProperties *iface, ULONG count,
1527 DBPROPSET propertyset[])
1528 {
1529 struct command *command = impl_from_ICommandProperties( iface );
1530 int i, j, k;
1531
1532 TRACE("%p %lu, %p\n", command, count, propertyset);
1533
1534 for(i=0; i < count; i++)
1535 {
1536 TRACE("set %s, count %ld\n", debugstr_guid(&propertyset[i].guidPropertySet), propertyset[i].cProperties);
1537 for(j=0; j < propertyset[i].cProperties; j++)
1538 {
1539 for(k=0; k < command->prop_count; k++)
1540 {
1541 if (command->properties[k].property_id == propertyset[i].rgProperties[j].dwPropertyID)
1542 {
1543 TRACE("Found property 0x%08lx\n", command->properties[k].property_id);
1544 if (command->properties[k].flags & DBPROPFLAGS_WRITE)
1545 {
1546 if (command->properties[k].vartype == VT_BOOL)
1547 {
1548 command->properties[k].value = V_BOOL(&propertyset[i].rgProperties[j].vValue);
1549 }
1550 else if (command->properties[k].vartype == VT_I4)
1551 {
1552 command->properties[k].value = V_I4(&propertyset[i].rgProperties[j].vValue);
1553 }
1554 else
1555 ERR("Unknown variant type %d\n", command->properties[j].vartype);
1556 }
1557 else
1558 WARN("Attempting to set Readonly property\n");
1559
1560 break;
1561 }
1562 }
1563 }
1564 }
1565 return S_OK;
1566 }
1567
1568 static const ICommandPropertiesVtbl commonpropsVtbl =
1569 {
1570 command_prop_QueryInterface,
1571 command_prop_AddRef,
1572 command_prop_Release,
1573 command_prop_GetProperties,
1574 command_prop_SetProperties
1575 };
1576
1577 static HRESULT WINAPI colsinfo_QueryInterface(IColumnsInfo *iface, REFIID riid, void **out)
1578 {
1579 struct command *command = impl_from_IColumnsInfo( iface );
1580 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1581 }
1582
1583 static ULONG WINAPI colsinfo_AddRef(IColumnsInfo *iface)
1584 {
1585 struct command *command = impl_from_IColumnsInfo( iface );
1586 return ICommandText_AddRef(&command->ICommandText_iface);
1587 }
1588
1589 static ULONG WINAPI colsinfo_Release(IColumnsInfo *iface)
1590 {
1591 struct command *command = impl_from_IColumnsInfo( iface );
1592 return ICommandText_Release(&command->ICommandText_iface);
1593 }
1594
1595 static HRESULT WINAPI colsinfo_GetColumnInfo(IColumnsInfo *iface, DBORDINAL *columns,
1596 DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
1597 {
1598 struct command *command = impl_from_IColumnsInfo( iface );
1599 FIXME("%p, %p, %p, %p\n", command, columns, colinfo, stringsbuffer);
1600 return E_NOTIMPL;
1601 }
1602
1603 static HRESULT WINAPI colsinfo_MapColumnIDs(IColumnsInfo *iface, DBORDINAL column_ids,
1604 const DBID *dbids, DBORDINAL *columns)
1605 {
1606 struct command *command = impl_from_IColumnsInfo( iface );
1607 FIXME("%p, %Iu, %p, %p\n", command, column_ids, dbids, columns);
1608 return E_NOTIMPL;
1609 }
1610
1611 static struct IColumnsInfoVtbl columninfoVtbl =
1612 {
1613 colsinfo_QueryInterface,
1614 colsinfo_AddRef,
1615 colsinfo_Release,
1616 colsinfo_GetColumnInfo,
1617 colsinfo_MapColumnIDs
1618 };
1619
1620 static HRESULT WINAPI converttype_QueryInterface(IConvertType *iface, REFIID riid, void **out)
1621 {
1622 struct command *command = impl_from_IConvertType( iface );
1623 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1624 }
1625
1626 static ULONG WINAPI converttype_AddRef(IConvertType *iface)
1627 {
1628 struct command *command = impl_from_IConvertType( iface );
1629 return ICommandText_AddRef(&command->ICommandText_iface);
1630 }
1631
1632 static ULONG WINAPI converttype_Release(IConvertType *iface)
1633 {
1634 struct command *command = impl_from_IConvertType( iface );
1635 return ICommandText_Release(&command->ICommandText_iface);
1636 }
1637
1638 static HRESULT WINAPI converttype_CanConvert(IConvertType *iface, DBTYPE from, DBTYPE to, DBCONVERTFLAGS flags)
1639 {
1640 struct command *command = impl_from_IConvertType( iface );
1641 FIXME("%p, %u, %d, 0x%08lx\n", command, from, to, flags);
1642 return E_NOTIMPL;
1643 }
1644
1645 static struct IConvertTypeVtbl converttypeVtbl =
1646 {
1647 converttype_QueryInterface,
1648 converttype_AddRef,
1649 converttype_Release,
1650 converttype_CanConvert
1651 };
1652
1653 static HRESULT WINAPI commandprepare_QueryInterface(ICommandPrepare *iface, REFIID riid, void **out)
1654 {
1655 struct command *command = impl_from_ICommandPrepare( iface );
1656 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1657 }
1658
1659 static ULONG WINAPI commandprepare_AddRef(ICommandPrepare *iface)
1660 {
1661 struct command *command = impl_from_ICommandPrepare( iface );
1662 return ICommandText_AddRef(&command->ICommandText_iface);
1663 }
1664
1665 static ULONG WINAPI commandprepare_Release(ICommandPrepare *iface)
1666 {
1667 struct command *command = impl_from_ICommandPrepare( iface );
1668 return ICommandText_Release(&command->ICommandText_iface);
1669 }
1670
1671 static HRESULT WINAPI commandprepare_Prepare(ICommandPrepare *iface, ULONG runs)
1672 {
1673 struct command *command = impl_from_ICommandPrepare( iface );
1674 RETCODE ret;
1675
1676 TRACE("%p, %lu\n", command, runs);
1677
1678 if (!command->query)
1679 return DB_E_NOCOMMAND;
1680
1681 if (command->hstmt)
1682 SQLFreeHandle(SQL_HANDLE_STMT, command->hstmt);
1683
1684 SQLAllocHandle(SQL_HANDLE_STMT, command->hdbc, &command->hstmt);
1685
1686 ret = SQLPrepareW(command->hstmt, command->query, SQL_NTS);
1687 if (ret != SQL_SUCCESS)
1688 {
1689 dump_sql_diag_records(SQL_HANDLE_STMT, command->hstmt);
1690 return E_FAIL;
1691 }
1692 return S_OK;
1693 }
1694
1695 static HRESULT WINAPI commandprepare_Unprepare(ICommandPrepare *iface)
1696 {
1697 struct command *command = impl_from_ICommandPrepare( iface );
1698 TRACE("%p\n", command);
1699 return S_OK;
1700 }
1701
1702 struct ICommandPrepareVtbl commandprepareVtbl =
1703 {
1704 commandprepare_QueryInterface,
1705 commandprepare_AddRef,
1706 commandprepare_Release,
1707 commandprepare_Prepare,
1708 commandprepare_Unprepare
1709 };
1710
1711 static HRESULT WINAPI cmd_with_params_QueryInterface(ICommandWithParameters *iface, REFIID riid, void **out)
1712 {
1713 struct command *command = impl_from_ICommandWithParameters( iface );
1714 return ICommandText_QueryInterface(&command->ICommandText_iface, riid, out);
1715 }
1716
1717 static ULONG WINAPI cmd_with_params_AddRef(ICommandWithParameters *iface)
1718 {
1719 struct command *command = impl_from_ICommandWithParameters( iface );
1720 return ICommandText_AddRef(&command->ICommandText_iface);
1721 }
1722
1723 static ULONG WINAPI cmd_with_params_Release(ICommandWithParameters *iface)
1724 {
1725 struct command *command = impl_from_ICommandWithParameters( iface );
1726 return ICommandText_Release(&command->ICommandText_iface);
1727 }
1728
1729 static HRESULT WINAPI cmd_with_params_GetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS *uparams,
1730 DBPARAMINFO **info, OLECHAR **buffer)
1731 {
1732 struct command *command = impl_from_ICommandWithParameters( iface );
1733 FIXME("%p, %p, %p, %p\n", command, uparams, info, buffer);
1734 return E_NOTIMPL;
1735 }
1736
1737 static HRESULT WINAPI cmd_with_params_MapParameterNames(ICommandWithParameters *iface, DB_UPARAMS uparams,
1738 LPCWSTR names[], DB_LPARAMS ordinals[])
1739 {
1740 struct command *command = impl_from_ICommandWithParameters( iface );
1741 FIXME("%p, %Iu, %p, %p\n", command, uparams, names, ordinals);
1742 return E_NOTIMPL;
1743 }
1744
1745 static HRESULT WINAPI cmd_with_params_SetParameterInfo(ICommandWithParameters *iface, DB_UPARAMS uparams,
1746 const DB_UPARAMS ordinals[], const DBPARAMBINDINFO bindinfo[])
1747 {
1748 struct command *command = impl_from_ICommandWithParameters( iface );
1749 FIXME("%p, %Iu, %p, %p\n", command, uparams, ordinals, bindinfo);
1750 return E_NOTIMPL;
1751 }
1752
1753 struct ICommandWithParametersVtbl command_with_params_vtbl =
1754 {
1755 cmd_with_params_QueryInterface,
1756 cmd_with_params_AddRef,
1757 cmd_with_params_Release,
1758 cmd_with_params_GetParameterInfo,
1759 cmd_with_params_MapParameterNames,
1760 cmd_with_params_SetParameterInfo
1761 };
1762
1763 static HRESULT WINAPI createcommand_CreateCommand(IDBCreateCommand *iface, IUnknown *outer, REFIID riid,
1764 IUnknown **out)
1765 {
1766 struct msdasql_session *session = impl_from_IDBCreateCommand( iface );
1767 struct command *command;
1768 HRESULT hr;
1769
1770 TRACE("%p, %p, %s, %p\n", session, outer, debugstr_guid(riid), out);
1771
1772 if (outer)
1773 FIXME("Outer not currently supported\n");
1774
1775 command = heap_alloc(sizeof(*command));
1776 if (!command)
1777 return E_OUTOFMEMORY;
1778
1779 command->ICommandText_iface.lpVtbl = &commandVtbl;
1780 command->ICommandProperties_iface.lpVtbl = &commonpropsVtbl;
1781 command->IColumnsInfo_iface.lpVtbl = &columninfoVtbl;
1782 command->IConvertType_iface.lpVtbl = &converttypeVtbl;
1783 command->ICommandPrepare_iface.lpVtbl = &commandprepareVtbl;
1784 command->ICommandWithParameters_iface.lpVtbl = &command_with_params_vtbl;
1785 command->refs = 1;
1786 command->query = NULL;
1787 command->hdbc = session->hdbc;
1788 command->hstmt = NULL;
1789
1790 command->prop_count = ARRAY_SIZE(msdasql_init_props);
1791 command->properties = heap_alloc(sizeof(msdasql_init_props));
1792 memcpy(command->properties, msdasql_init_props, sizeof(msdasql_init_props));
1793
1794 IUnknown_QueryInterface(&session->session_iface, &IID_IUnknown, (void**)&command->session);
1795
1796 hr = ICommandText_QueryInterface(&command->ICommandText_iface, riid, (void**)out);
1797 ICommandText_Release(&command->ICommandText_iface);
1798 return hr;
1799 }
1800
1801 static const IDBCreateCommandVtbl createcommandVtbl =
1802 {
1803 createcommand_QueryInterface,
1804 createcommand_AddRef,
1805 createcommand_Release,
1806 createcommand_CreateCommand
1807 };
1808
1809 static HRESULT WINAPI transjoin_QueryInterface(ITransactionJoin *iface, REFIID riid, void **out)
1810 {
1811 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1812 return IUnknown_QueryInterface(&session->session_iface, riid, out);
1813 }
1814
1815 static ULONG WINAPI transjoin_AddRef(ITransactionJoin *iface)
1816 {
1817 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1818 return IUnknown_AddRef(&session->session_iface);
1819 }
1820
1821 static ULONG WINAPI transjoin_Release(ITransactionJoin *iface)
1822 {
1823 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1824 return IUnknown_Release(&session->session_iface);
1825 }
1826
1827 static HRESULT WINAPI transjoin_GetOptionsObject(ITransactionJoin *iface, ITransactionOptions **options)
1828 {
1829 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1830
1831 FIXME("%p, %p\n", session, options);
1832
1833 return E_NOTIMPL;
1834 }
1835
1836 static HRESULT WINAPI transjoin_JoinTransaction(ITransactionJoin *iface, IUnknown *unk, ISOLEVEL level,
1837 ULONG flags, ITransactionOptions *options)
1838 {
1839 struct msdasql_session *session = impl_from_ITransactionJoin( iface );
1840
1841 FIXME("%p, %p, %lu, 0x%08lx, %p\n", session, unk, level, flags, options);
1842
1843 return E_NOTIMPL;
1844 }
1845
1846 static const ITransactionJoinVtbl transactionjoinVtbl =
1847 {
1848 transjoin_QueryInterface,
1849 transjoin_AddRef,
1850 transjoin_Release,
1851 transjoin_GetOptionsObject,
1852 transjoin_JoinTransaction
1853 };
1854
1855 static HRESULT WINAPI transaction_QueryInterface(ITransaction *iface, REFIID riid, void **out)
1856 {
1857 struct msdasql_session *session = impl_from_ITransaction( iface );
1858 return IUnknown_QueryInterface(&session->session_iface, riid, out);
1859 }
1860
1861 static ULONG WINAPI transaction_AddRef(ITransaction *iface)
1862 {
1863 struct msdasql_session *session = impl_from_ITransaction( iface );
1864 return IUnknown_AddRef(&session->session_iface);
1865 }
1866
1867 static ULONG WINAPI transaction_Release(ITransaction *iface)
1868 {
1869 struct msdasql_session *session = impl_from_ITransaction( iface );
1870 return IUnknown_Release(&session->session_iface);
1871 }
1872
1873 static HRESULT WINAPI transaction_Commit(ITransaction *iface, BOOL retaining, DWORD tc, DWORD rm)
1874 {
1875 struct msdasql_session *session = impl_from_ITransaction( iface );
1876
1877 FIXME("%p, %d, %ld, %ld\n", session, retaining, tc, rm);
1878
1879 return E_NOTIMPL;
1880 }
1881
1882 static HRESULT WINAPI transaction_Abort(ITransaction *iface, BOID *reason, BOOL retaining, BOOL async)
1883 {
1884 struct msdasql_session *session = impl_from_ITransaction( iface );
1885
1886 FIXME("%p, %p, %d, %d\n", session, reason, retaining, async);
1887
1888 return E_NOTIMPL;
1889 }
1890
1891 static HRESULT WINAPI transaction_GetTransactionInfo(ITransaction *iface, XACTTRANSINFO *info)
1892 {
1893 struct msdasql_session *session = impl_from_ITransaction( iface );
1894
1895 FIXME("%p, %p\n", session, info);
1896
1897 return E_NOTIMPL;
1898 }
1899
1900 static const ITransactionVtbl transactionVtbl =
1901 {
1902 transaction_QueryInterface,
1903 transaction_AddRef,
1904 transaction_Release,
1905 transaction_Commit,
1906 transaction_Abort,
1907 transaction_GetTransactionInfo
1908 };
1909
1910 HRESULT create_db_session(REFIID riid, IUnknown *datasource, HDBC hdbc, void **unk)
1911 {
1912 struct msdasql_session *session;
1913 HRESULT hr;
1914
1915 session = heap_alloc(sizeof(*session));
1916 if (!session)
1917 return E_OUTOFMEMORY;
1918
1919 session->session_iface.lpVtbl = &unkfactoryVtbl;
1920 session->IGetDataSource_iface.lpVtbl = &datasourceVtbl;
1921 session->IOpenRowset_iface.lpVtbl = &openrowsetVtbl;
1922 session->ISessionProperties_iface.lpVtbl = &propertiesVtbl;
1923 session->IDBCreateCommand_iface.lpVtbl = &createcommandVtbl;
1924 session->ITransactionJoin_iface.lpVtbl = &transactionjoinVtbl;
1925 session->ITransaction_iface.lpVtbl = &transactionVtbl;
1926
1927 IUnknown_QueryInterface(datasource, &IID_IUnknown, (void**)&session->datasource);
1928 session->refs = 1;
1929 session->hdbc = hdbc;
1930
1931 hr = IUnknown_QueryInterface(&session->session_iface, riid, unk);
1932 IUnknown_Release(&session->session_iface);
1933 return hr;
1934 }
Windows API implementation