?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfreadwrite/reader: Add missing allocation check (Coverity).
[wine/zf.git] / dlls / msado15 / recordset.c
blob68d4c22d802129c7377467b834bb6af80133224a
1 /*
2 * Copyright 2019 Hans Leidekker for CodeWeavers
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 #include <stdarg.h>
20 #include <assert.h>
21 #include "windef.h"
22 #include "winbase.h"
23 #define COBJMACROS
24 #include "objbase.h"
25 #include "msado15_backcompat.h"
26 #include "oledb.h"
27
28 #include "wine/debug.h"
29 #include "wine/heap.h"
30
31 #include "msado15_private.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(msado15);
34
35 struct fields;
36 struct recordset
37 {
38 _Recordset Recordset_iface;
39 ADORecordsetConstruction ADORecordsetConstruction_iface;
40 ISupportErrorInfo ISupportErrorInfo_iface;
41 LONG refs;
42 LONG state;
43 struct fields *fields;
44 LONG count;
45 LONG allocated;
46 LONG index;
47 VARIANT *data;
48 CursorLocationEnum cursor_location;
49 CursorTypeEnum cursor_type;
50 IRowset *row_set;
51 };
52
53 struct fields
54 {
55 Fields Fields_iface;
56 ISupportErrorInfo ISupportErrorInfo_iface;
57 LONG refs;
58 Field **field;
59 ULONG count;
60 ULONG allocated;
61 struct recordset *recordset;
62 };
63
64 struct field
65 {
66 Field Field_iface;
67 ISupportErrorInfo ISupportErrorInfo_iface;
68 LONG refs;
69 WCHAR *name;
70 DataTypeEnum type;
71 LONG defined_size;
72 LONG attrs;
73 LONG index;
74 struct recordset *recordset;
75 };
76
77 static inline struct field *impl_from_Field( Field *iface )
78 {
79 return CONTAINING_RECORD( iface, struct field, Field_iface );
80 }
81
82 static ULONG WINAPI field_AddRef( Field *iface )
83 {
84 struct field *field = impl_from_Field( iface );
85 LONG refs = InterlockedIncrement( &field->refs );
86 TRACE( "%p new refcount %d\n", field, refs );
87 return refs;
88 }
89
90 static ULONG WINAPI field_Release( Field *iface )
91 {
92 struct field *field = impl_from_Field( iface );
93 LONG refs = InterlockedDecrement( &field->refs );
94 TRACE( "%p new refcount %d\n", field, refs );
95 if (!refs)
96 {
97 TRACE( "destroying %p\n", field );
98 heap_free( field->name );
99 heap_free( field );
100 }
101 return refs;
102 }
103
104 static HRESULT WINAPI field_QueryInterface( Field *iface, REFIID riid, void **obj )
105 {
106 struct field *field = impl_from_Field( iface );
107 TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), obj );
108
109 if (IsEqualGUID( riid, &IID_Field ) || IsEqualGUID( riid, &IID_IDispatch ) ||
110 IsEqualGUID( riid, &IID_IUnknown ))
111 {
112 *obj = iface;
113 }
114 else if (IsEqualGUID( riid, &IID_ISupportErrorInfo ))
115 {
116 *obj = &field->ISupportErrorInfo_iface;
117 }
118 else
119 {
120 FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
121 return E_NOINTERFACE;
122 }
123 field_AddRef( iface );
124 return S_OK;
125 }
126
127 static HRESULT WINAPI field_GetTypeInfoCount( Field *iface, UINT *count )
128 {
129 struct field *field = impl_from_Field( iface );
130 TRACE( "%p, %p\n", field, count );
131 *count = 1;
132 return S_OK;
133 }
134
135 static HRESULT WINAPI field_GetTypeInfo( Field *iface, UINT index, LCID lcid, ITypeInfo **info )
136 {
137 struct field *field = impl_from_Field( iface );
138 TRACE( "%p, %u, %u, %p\n", field, index, lcid, info );
139 return get_typeinfo(Field_tid, info);
140 }
141
142 static HRESULT WINAPI field_GetIDsOfNames( Field *iface, REFIID riid, LPOLESTR *names, UINT count,
143 LCID lcid, DISPID *dispid )
144 {
145 struct field *field = impl_from_Field( iface );
146 HRESULT hr;
147 ITypeInfo *typeinfo;
148
149 TRACE( "%p, %s, %p, %u, %u, %p\n", field, debugstr_guid(riid), names, count, lcid, dispid );
150
151 hr = get_typeinfo(Field_tid, &typeinfo);
152 if(SUCCEEDED(hr))
153 {
154 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispid);
155 ITypeInfo_Release(typeinfo);
156 }
157
158 return hr;
159 }
160
161 static HRESULT WINAPI field_Invoke( Field *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
162 DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
163 {
164 struct field *field = impl_from_Field( iface );
165 HRESULT hr;
166 ITypeInfo *typeinfo;
167
168 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", field, member, debugstr_guid(riid), lcid, flags, params,
169 result, excep_info, arg_err );
170
171 hr = get_typeinfo(Field_tid, &typeinfo);
172 if(SUCCEEDED(hr))
173 {
174 hr = ITypeInfo_Invoke(typeinfo, &field->Field_iface, member, flags, params,
175 result, excep_info, arg_err);
176 ITypeInfo_Release(typeinfo);
177 }
178
179 return hr;
180 }
181
182 static HRESULT WINAPI field_get_Properties( Field *iface, Properties **obj )
183 {
184 FIXME( "%p, %p\n", iface, obj );
185 return E_NOTIMPL;
186 }
187
188 static HRESULT WINAPI field_get_ActualSize( Field *iface, LONG *size )
189 {
190 FIXME( "%p, %p\n", iface, size );
191 return E_NOTIMPL;
192 }
193
194 static HRESULT WINAPI field_get_Attributes( Field *iface, LONG *attrs )
195 {
196 struct field *field = impl_from_Field( iface );
197
198 TRACE( "%p, %p\n", field, attrs );
199
200 *attrs = field->attrs;
201 return S_OK;
202 }
203
204 static HRESULT WINAPI field_get_DefinedSize( Field *iface, LONG *size )
205 {
206 struct field *field = impl_from_Field( iface );
207
208 TRACE( "%p, %p\n", field, size );
209
210 *size = field->defined_size;
211 return S_OK;
212 }
213
214 static HRESULT WINAPI field_get_Name( Field *iface, BSTR *str )
215 {
216 struct field *field = impl_from_Field( iface );
217 BSTR name;
218
219 TRACE( "%p, %p\n", field, str );
220
221 if (!(name = SysAllocString( field->name ))) return E_OUTOFMEMORY;
222 *str = name;
223 return S_OK;
224 }
225
226 static HRESULT WINAPI field_get_Type( Field *iface, DataTypeEnum *type )
227 {
228 struct field *field = impl_from_Field( iface );
229
230 TRACE( "%p, %p\n", field, type );
231
232 *type = field->type;
233 return S_OK;
234 }
235
236 static LONG get_column_count( struct recordset *recordset )
237 {
238 return recordset->fields->count;
239 }
240
241 static HRESULT WINAPI field_get_Value( Field *iface, VARIANT *val )
242 {
243 struct field *field = impl_from_Field( iface );
244 ULONG row = field->recordset->index, col = field->index, col_count;
245 VARIANT copy;
246 HRESULT hr;
247
248 TRACE( "%p, %p\n", field, val );
249
250 if (field->recordset->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed );
251 if (field->recordset->index < 0) return MAKE_ADO_HRESULT( adErrNoCurrentRecord );
252
253 col_count = get_column_count( field->recordset );
254
255 VariantInit( &copy );
256 if ((hr = VariantCopy( &copy, &field->recordset->data[row * col_count + col] )) != S_OK) return hr;
257
258 *val = copy;
259 return S_OK;
260 }
261
262 static HRESULT WINAPI field_put_Value( Field *iface, VARIANT val )
263 {
264 struct field *field = impl_from_Field( iface );
265 ULONG row = field->recordset->index, col = field->index, col_count;
266 VARIANT copy;
267 HRESULT hr;
268
269 TRACE( "%p, %s\n", field, debugstr_variant(&val) );
270
271 if (field->recordset->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed );
272 if (field->recordset->index < 0) return MAKE_ADO_HRESULT( adErrNoCurrentRecord );
273
274 col_count = get_column_count( field->recordset );
275
276 VariantInit( &copy );
277 if ((hr = VariantCopy( &copy, &val )) != S_OK) return hr;
278
279 field->recordset->data[row * col_count + col] = copy;
280 return S_OK;
281 }
282
283 static HRESULT WINAPI field_get_Precision( Field *iface, unsigned char *precision )
284 {
285 FIXME( "%p, %p\n", iface, precision );
286 return E_NOTIMPL;
287 }
288
289 static HRESULT WINAPI field_get_NumericScale( Field *iface, unsigned char *scale )
290 {
291 FIXME( "%p, %p\n", iface, scale );
292 return E_NOTIMPL;
293 }
294
295 static HRESULT WINAPI field_AppendChunk( Field *iface, VARIANT data )
296 {
297 FIXME( "%p, %s\n", iface, debugstr_variant(&data) );
298 return E_NOTIMPL;
299 }
300
301 static HRESULT WINAPI field_GetChunk( Field *iface, LONG length, VARIANT *var )
302 {
303 FIXME( "%p, %d, %p\n", iface, length, var );
304 return E_NOTIMPL;
305 }
306
307 static HRESULT WINAPI field_get_OriginalValue( Field *iface, VARIANT *val )
308 {
309 FIXME( "%p, %p\n", iface, val );
310 return E_NOTIMPL;
311 }
312
313 static HRESULT WINAPI field_get_UnderlyingValue( Field *iface, VARIANT *val )
314 {
315 FIXME( "%p, %p\n", iface, val );
316 return E_NOTIMPL;
317 }
318
319 static HRESULT WINAPI field_get_DataFormat( Field *iface, IUnknown **format )
320 {
321 FIXME( "%p, %p\n", iface, format );
322 return E_NOTIMPL;
323 }
324
325 static HRESULT WINAPI field_putref_DataFormat( Field *iface, IUnknown *format )
326 {
327 FIXME( "%p, %p\n", iface, format );
328 return E_NOTIMPL;
329 }
330
331 static HRESULT WINAPI field_put_Precision( Field *iface, unsigned char precision )
332 {
333 FIXME( "%p, %c\n", iface, precision );
334 return E_NOTIMPL;
335 }
336
337 static HRESULT WINAPI field_put_NumericScale( Field *iface, unsigned char scale )
338 {
339 FIXME( "%p, %c\n", iface, scale );
340 return E_NOTIMPL;
341 }
342
343 static HRESULT WINAPI field_put_Type( Field *iface, DataTypeEnum type )
344 {
345 struct field *field = impl_from_Field( iface );
346
347 TRACE( "%p, %u\n", field, type );
348
349 field->type = type;
350 return S_OK;
351 }
352
353 static HRESULT WINAPI field_put_DefinedSize( Field *iface, LONG size )
354 {
355 struct field *field = impl_from_Field( iface );
356
357 TRACE( "%p, %d\n", field, size );
358
359 field->defined_size = size;
360 return S_OK;
361 }
362
363 static HRESULT WINAPI field_put_Attributes( Field *iface, LONG attrs )
364 {
365 struct field *field = impl_from_Field( iface );
366
367 TRACE( "%p, %d\n", field, attrs );
368
369 field->attrs = attrs;
370 return S_OK;
371 }
372
373 static HRESULT WINAPI field_get_Status( Field *iface, LONG *status )
374 {
375 FIXME( "%p, %p\n", iface, status );
376 return E_NOTIMPL;
377 }
378
379 static const struct FieldVtbl field_vtbl =
380 {
381 field_QueryInterface,
382 field_AddRef,
383 field_Release,
384 field_GetTypeInfoCount,
385 field_GetTypeInfo,
386 field_GetIDsOfNames,
387 field_Invoke,
388 field_get_Properties,
389 field_get_ActualSize,
390 field_get_Attributes,
391 field_get_DefinedSize,
392 field_get_Name,
393 field_get_Type,
394 field_get_Value,
395 field_put_Value,
396 field_get_Precision,
397 field_get_NumericScale,
398 field_AppendChunk,
399 field_GetChunk,
400 field_get_OriginalValue,
401 field_get_UnderlyingValue,
402 field_get_DataFormat,
403 field_putref_DataFormat,
404 field_put_Precision,
405 field_put_NumericScale,
406 field_put_Type,
407 field_put_DefinedSize,
408 field_put_Attributes,
409 field_get_Status
410 };
411
412 static inline struct field *field_from_ISupportErrorInfo( ISupportErrorInfo *iface )
413 {
414 return CONTAINING_RECORD( iface, struct field, ISupportErrorInfo_iface );
415 }
416
417 static HRESULT WINAPI field_supporterrorinfo_QueryInterface( ISupportErrorInfo *iface, REFIID riid, void **obj )
418 {
419 struct field *field = field_from_ISupportErrorInfo( iface );
420 return Field_QueryInterface( &field->Field_iface, riid, obj );
421 }
422
423 static ULONG WINAPI field_supporterrorinfo_AddRef( ISupportErrorInfo *iface )
424 {
425 struct field *field = field_from_ISupportErrorInfo( iface );
426 return Field_AddRef( &field->Field_iface );
427 }
428
429 static ULONG WINAPI field_supporterrorinfo_Release( ISupportErrorInfo *iface )
430 {
431 struct field *field = field_from_ISupportErrorInfo( iface );
432 return Field_Release( &field->Field_iface );
433 }
434
435 static HRESULT WINAPI field_supporterrorinfo_InterfaceSupportsErrorInfo( ISupportErrorInfo *iface, REFIID riid )
436 {
437 struct field *field = field_from_ISupportErrorInfo( iface );
438 FIXME( "%p, %s\n", field, debugstr_guid(riid) );
439 return S_FALSE;
440 }
441
442 static const ISupportErrorInfoVtbl field_supporterrorinfo_vtbl =
443 {
444 field_supporterrorinfo_QueryInterface,
445 field_supporterrorinfo_AddRef,
446 field_supporterrorinfo_Release,
447 field_supporterrorinfo_InterfaceSupportsErrorInfo
448 };
449
450 static HRESULT Field_create( const WCHAR *name, LONG index, struct recordset *recordset, Field **obj )
451 {
452 struct field *field;
453
454 if (!(field = heap_alloc_zero( sizeof(*field) ))) return E_OUTOFMEMORY;
455 field->Field_iface.lpVtbl = &field_vtbl;
456 field->ISupportErrorInfo_iface.lpVtbl = &field_supporterrorinfo_vtbl;
457 if (!(field->name = strdupW( name )))
458 {
459 heap_free( field );
460 return E_OUTOFMEMORY;
461 }
462 field->index = index;
463 field->recordset = recordset;
464
465 *obj = &field->Field_iface;
466 TRACE( "returning iface %p\n", *obj );
467 return S_OK;
468 }
469
470 static inline struct fields *impl_from_Fields( Fields *iface )
471 {
472 return CONTAINING_RECORD( iface, struct fields, Fields_iface );
473 }
474
475 static ULONG WINAPI fields_AddRef( Fields *iface )
476 {
477 struct fields *fields = impl_from_Fields( iface );
478 LONG refs = InterlockedIncrement( &fields->refs );
479 TRACE( "%p new refcount %d\n", fields, refs );
480 return refs;
481 }
482
483 static ULONG WINAPI fields_Release( Fields *iface )
484 {
485 struct fields *fields = impl_from_Fields( iface );
486 LONG refs = InterlockedDecrement( &fields->refs );
487 TRACE( "%p new refcount %d\n", fields, refs );
488 if (!refs)
489 {
490 if (fields->recordset) _Recordset_Release( &fields->recordset->Recordset_iface );
491 fields->recordset = NULL;
492 WARN( "not destroying %p\n", fields );
493 return InterlockedIncrement( &fields->refs );
494 }
495 return refs;
496 }
497
498 static HRESULT WINAPI fields_QueryInterface( Fields *iface, REFIID riid, void **obj )
499 {
500 struct fields *fields = impl_from_Fields( iface );
501 TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), obj );
502
503 if (IsEqualGUID( riid, &IID_Fields ) || IsEqualGUID( riid, &IID_IDispatch ) ||
504 IsEqualGUID( riid, &IID_IUnknown ))
505 {
506 *obj = iface;
507 }
508 else if (IsEqualGUID( riid, &IID_ISupportErrorInfo ))
509 {
510 *obj = &fields->ISupportErrorInfo_iface;
511 }
512 else
513 {
514 FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
515 return E_NOINTERFACE;
516 }
517 fields_AddRef( iface );
518 return S_OK;
519 }
520
521 static HRESULT WINAPI fields_GetTypeInfoCount( Fields *iface, UINT *count )
522 {
523 struct fields *fields = impl_from_Fields( iface );
524 TRACE( "%p, %p\n", fields, count );
525 *count = 1;
526 return S_OK;
527 }
528
529 static HRESULT WINAPI fields_GetTypeInfo( Fields *iface, UINT index, LCID lcid, ITypeInfo **info )
530 {
531 struct fields *fields = impl_from_Fields( iface );
532 TRACE( "%p, %u, %u, %p\n", fields, index, lcid, info );
533 return get_typeinfo(Fields_tid, info);
534 }
535
536 static HRESULT WINAPI fields_GetIDsOfNames( Fields *iface, REFIID riid, LPOLESTR *names, UINT count,
537 LCID lcid, DISPID *dispid )
538 {
539 struct fields *fields = impl_from_Fields( iface );
540 HRESULT hr;
541 ITypeInfo *typeinfo;
542
543 TRACE( "%p, %s, %p, %u, %u, %p\n", fields, debugstr_guid(riid), names, count, lcid, dispid );
544
545 hr = get_typeinfo(Fields_tid, &typeinfo);
546 if(SUCCEEDED(hr))
547 {
548 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispid);
549 ITypeInfo_Release(typeinfo);
550 }
551
552 return hr;
553 }
554
555 static HRESULT WINAPI fields_Invoke( Fields *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
556 DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
557 {
558 struct fields *fields = impl_from_Fields( iface );
559 HRESULT hr;
560 ITypeInfo *typeinfo;
561
562 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", fields, member, debugstr_guid(riid), lcid, flags, params,
563 result, excep_info, arg_err );
564
565 hr = get_typeinfo(Fields_tid, &typeinfo);
566 if(SUCCEEDED(hr))
567 {
568 hr = ITypeInfo_Invoke(typeinfo, &fields->Fields_iface, member, flags, params,
569 result, excep_info, arg_err);
570 ITypeInfo_Release(typeinfo);
571 }
572
573 return hr;
574 }
575
576 static HRESULT WINAPI fields_get_Count( Fields *iface, LONG *count )
577 {
578 struct fields *fields = impl_from_Fields( iface );
579
580 TRACE( "%p, %p\n", fields, count );
581
582 *count = fields->count;
583 return S_OK;
584 }
585
586 static HRESULT WINAPI fields__NewEnum( Fields *iface, IUnknown **obj )
587 {
588 FIXME( "%p, %p\n", iface, obj );
589 return E_NOTIMPL;
590 }
591
592 static HRESULT WINAPI fields_Refresh( Fields *iface )
593 {
594 FIXME( "%p\n", iface );
595 return E_NOTIMPL;
596 }
597
598 static HRESULT map_index( struct fields *fields, VARIANT *index, ULONG *ret )
599 {
600 ULONG i;
601
602 if (V_VT( index ) != VT_BSTR)
603 {
604 FIXME( "variant type %u not supported\n", V_VT( index ) );
605 return E_INVALIDARG;
606 }
607
608 for (i = 0; i < fields->count; i++)
609 {
610 BSTR name;
611 BOOL match;
612 HRESULT hr;
613
614 if ((hr = Field_get_Name( fields->field[i], &name )) != S_OK) return hr;
615 match = !wcsicmp( V_BSTR( index ), name );
616 SysFreeString( name );
617 if (match)
618 {
619 *ret = i;
620 return S_OK;
621 }
622 }
623
624 return MAKE_ADO_HRESULT(adErrItemNotFound);
625 }
626
627 static HRESULT WINAPI fields_get_Item( Fields *iface, VARIANT index, Field **obj )
628 {
629 struct fields *fields = impl_from_Fields( iface );
630 HRESULT hr;
631 ULONG i;
632
633 TRACE( "%p, %s, %p\n", fields, debugstr_variant(&index), obj );
634
635 if ((hr = map_index( fields, &index, &i )) != S_OK) return hr;
636
637 Field_AddRef( fields->field[i] );
638 *obj = fields->field[i];
639 return S_OK;
640 }
641
642 static BOOL resize_fields( struct fields *fields, ULONG count )
643 {
644 if (count > fields->allocated)
645 {
646 Field **tmp;
647 ULONG new_size = max( count, fields->allocated * 2 );
648 if (!(tmp = heap_realloc( fields->field, new_size * sizeof(*tmp) ))) return FALSE;
649 fields->field = tmp;
650 fields->allocated = new_size;
651 }
652
653 fields->count = count;
654 return TRUE;
655 }
656
657 static HRESULT append_field( struct fields *fields, BSTR name, DataTypeEnum type, LONG size, FieldAttributeEnum attr,
658 VARIANT *value )
659 {
660 Field *field;
661 HRESULT hr;
662
663 if ((hr = Field_create( name, fields->count, fields->recordset, &field )) != S_OK) return hr;
664 Field_put_Type( field, type );
665 Field_put_DefinedSize( field, size );
666 if (attr != adFldUnspecified) Field_put_Attributes( field, attr );
667 if (value) FIXME( "ignoring value %s\n", debugstr_variant(value) );
668
669 if (!(resize_fields( fields, fields->count + 1 )))
670 {
671 Field_Release( field );
672 return E_OUTOFMEMORY;
673 }
674
675 fields->field[fields->count - 1] = field;
676 return S_OK;
677 }
678
679 static HRESULT WINAPI fields__Append( Fields *iface, BSTR name, DataTypeEnum type, LONG size, FieldAttributeEnum attr )
680 {
681 struct fields *fields = impl_from_Fields( iface );
682
683 TRACE( "%p, %s, %u, %d, %d\n", fields, debugstr_w(name), type, size, attr );
684
685 return append_field( fields, name, type, size, attr, NULL );
686 }
687
688 static HRESULT WINAPI fields_Delete( Fields *iface, VARIANT index )
689 {
690 FIXME( "%p, %s\n", iface, debugstr_variant(&index) );
691 return E_NOTIMPL;
692 }
693
694 static HRESULT WINAPI fields_Append( Fields *iface, BSTR name, DataTypeEnum type, LONG size, FieldAttributeEnum attr,
695 VARIANT value )
696 {
697 struct fields *fields = impl_from_Fields( iface );
698
699 TRACE( "%p, %s, %u, %d, %d, %s\n", fields, debugstr_w(name), type, size, attr, debugstr_variant(&value) );
700
701 return append_field( fields, name, type, size, attr, &value );
702 }
703
704 static HRESULT WINAPI fields_Update( Fields *iface )
705 {
706 FIXME( "%p\n", iface );
707 return E_NOTIMPL;
708 }
709
710 static HRESULT WINAPI fields_Resync( Fields *iface, ResyncEnum resync_values )
711 {
712 FIXME( "%p, %u\n", iface, resync_values );
713 return E_NOTIMPL;
714 }
715
716 static HRESULT WINAPI fields_CancelUpdate( Fields *iface )
717 {
718 FIXME( "%p\n", iface );
719 return E_NOTIMPL;
720 }
721
722 static const struct FieldsVtbl fields_vtbl =
723 {
724 fields_QueryInterface,
725 fields_AddRef,
726 fields_Release,
727 fields_GetTypeInfoCount,
728 fields_GetTypeInfo,
729 fields_GetIDsOfNames,
730 fields_Invoke,
731 fields_get_Count,
732 fields__NewEnum,
733 fields_Refresh,
734 fields_get_Item,
735 fields__Append,
736 fields_Delete,
737 fields_Append,
738 fields_Update,
739 fields_Resync,
740 fields_CancelUpdate
741 };
742
743 static inline struct fields *fields_from_ISupportErrorInfo( ISupportErrorInfo *iface )
744 {
745 return CONTAINING_RECORD( iface, struct fields, ISupportErrorInfo_iface );
746 }
747
748 static HRESULT WINAPI fields_supporterrorinfo_QueryInterface( ISupportErrorInfo *iface, REFIID riid, void **obj )
749 {
750 struct fields *fields = fields_from_ISupportErrorInfo( iface );
751 return Fields_QueryInterface( &fields->Fields_iface, riid, obj );
752 }
753
754 static ULONG WINAPI fields_supporterrorinfo_AddRef( ISupportErrorInfo *iface )
755 {
756 struct fields *fields = fields_from_ISupportErrorInfo( iface );
757 return Fields_AddRef( &fields->Fields_iface );
758 }
759
760 static ULONG WINAPI fields_supporterrorinfo_Release( ISupportErrorInfo *iface )
761 {
762 struct fields *fields = fields_from_ISupportErrorInfo( iface );
763 return Fields_Release( &fields->Fields_iface );
764 }
765
766 static HRESULT WINAPI fields_supporterrorinfo_InterfaceSupportsErrorInfo( ISupportErrorInfo *iface, REFIID riid )
767 {
768 struct fields *fields = fields_from_ISupportErrorInfo( iface );
769 FIXME( "%p, %s\n", fields, debugstr_guid(riid) );
770 return S_FALSE;
771 }
772
773 static const ISupportErrorInfoVtbl fields_supporterrorinfo_vtbl =
774 {
775 fields_supporterrorinfo_QueryInterface,
776 fields_supporterrorinfo_AddRef,
777 fields_supporterrorinfo_Release,
778 fields_supporterrorinfo_InterfaceSupportsErrorInfo
779 };
780
781 static void map_rowset_fields(struct recordset *recordset, struct fields *fields)
782 {
783 HRESULT hr;
784 IColumnsInfo *columninfo;
785 DBORDINAL columns, i;
786 DBCOLUMNINFO *colinfo;
787 OLECHAR *stringsbuffer;
788
789 /* Not Finding the interface or GetColumnInfo failing just causes 0 Fields to be returned */
790 hr = IRowset_QueryInterface(recordset->row_set, &IID_IColumnsInfo, (void**)&columninfo);
791 if (FAILED(hr))
792 return;
793
794 hr = IColumnsInfo_GetColumnInfo(columninfo, &columns, &colinfo, &stringsbuffer);
795 if (SUCCEEDED(hr))
796 {
797 for (i=0; i < columns; i++)
798 {
799 TRACE("Adding Column %lu, pwszName: %s, pTypeInfo %p, iOrdinal %lu, dwFlags 0x%08x, "
800 "ulColumnSize %lu, wType %d, bPrecision %d, bScale %d\n",
801 i, debugstr_w(colinfo[i].pwszName), colinfo[i].pTypeInfo, colinfo[i].iOrdinal,
802 colinfo[i].dwFlags, colinfo[i].ulColumnSize, colinfo[i].wType,
803 colinfo[i].bPrecision, colinfo[i].bScale);
804
805 hr = append_field(fields, colinfo[i].pwszName, colinfo[i].wType, colinfo[i].ulColumnSize,
806 colinfo[i].dwFlags, NULL);
807 if (FAILED(hr))
808 {
809 ERR("Failed to add Field name - 0x%08x\n", hr);
810 return;
811 }
812 }
813
814 CoTaskMemFree(colinfo);
815 CoTaskMemFree(stringsbuffer);
816 }
817
818 IColumnsInfo_Release(columninfo);
819 }
820
821 static HRESULT fields_create( struct recordset *recordset, struct fields **ret )
822 {
823 struct fields *fields;
824
825 if (!(fields = heap_alloc_zero( sizeof(*fields) ))) return E_OUTOFMEMORY;
826 fields->Fields_iface.lpVtbl = &fields_vtbl;
827 fields->ISupportErrorInfo_iface.lpVtbl = &fields_supporterrorinfo_vtbl;
828 fields->refs = 1;
829 fields->recordset = recordset;
830 _Recordset_AddRef( &fields->recordset->Recordset_iface );
831
832 if ( recordset->row_set )
833 map_rowset_fields(recordset, fields);
834
835 *ret = fields;
836 TRACE( "returning %p\n", *ret );
837 return S_OK;
838 }
839
840 static inline struct recordset *impl_from_Recordset( _Recordset *iface )
841 {
842 return CONTAINING_RECORD( iface, struct recordset, Recordset_iface );
843 }
844
845 static inline struct recordset *impl_from_ADORecordsetConstruction( ADORecordsetConstruction *iface )
846 {
847 return CONTAINING_RECORD( iface, struct recordset, ADORecordsetConstruction_iface );
848 }
849
850 static ULONG WINAPI recordset_AddRef( _Recordset *iface )
851 {
852 struct recordset *recordset = impl_from_Recordset( iface );
853 LONG refs = InterlockedIncrement( &recordset->refs );
854 TRACE( "%p new refcount %d\n", recordset, refs );
855 return refs;
856 }
857
858 static void close_recordset( struct recordset *recordset )
859 {
860 ULONG row, col, col_count;
861
862 if ( recordset->row_set ) IRowset_Release( recordset->row_set );
863 recordset->row_set = NULL;
864
865 if (!recordset->fields) return;
866 col_count = get_column_count( recordset );
867
868 Fields_Release( &recordset->fields->Fields_iface );
869 recordset->fields = NULL;
870
871 for (row = 0; row < recordset->count; row++)
872 for (col = 0; col < col_count; col++) VariantClear( &recordset->data[row * col_count + col] );
873
874 recordset->count = recordset->allocated = recordset->index = 0;
875 heap_free( recordset->data );
876 recordset->data = NULL;
877 }
878
879 static ULONG WINAPI recordset_Release( _Recordset *iface )
880 {
881 struct recordset *recordset = impl_from_Recordset( iface );
882 LONG refs = InterlockedDecrement( &recordset->refs );
883 TRACE( "%p new refcount %d\n", recordset, refs );
884 if (!refs)
885 {
886 TRACE( "destroying %p\n", recordset );
887 close_recordset( recordset );
888 heap_free( recordset );
889 }
890 return refs;
891 }
892
893 static HRESULT WINAPI recordset_QueryInterface( _Recordset *iface, REFIID riid, void **obj )
894 {
895 struct recordset *recordset = impl_from_Recordset( iface );
896 TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), obj );
897
898 *obj = NULL;
899
900 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDispatch) ||
901 IsEqualIID(riid, &IID__ADO) || IsEqualIID(riid, &IID_Recordset15) ||
902 IsEqualIID(riid, &IID_Recordset20) || IsEqualIID(riid, &IID_Recordset21) ||
903 IsEqualIID(riid, &IID__Recordset))
904 {
905 *obj = iface;
906 }
907 else if (IsEqualGUID( riid, &IID_ISupportErrorInfo ))
908 {
909 *obj = &recordset->ISupportErrorInfo_iface;
910 }
911 else if (IsEqualGUID( riid, &IID_ADORecordsetConstruction ))
912 {
913 *obj = &recordset->ADORecordsetConstruction_iface;
914 }
915 else if (IsEqualGUID( riid, &IID_IRunnableObject ))
916 {
917 TRACE("IID_IRunnableObject not supported returning NULL\n");
918 return E_NOINTERFACE;
919 }
920 else
921 {
922 FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
923 return E_NOINTERFACE;
924 }
925 recordset_AddRef( iface );
926 return S_OK;
927 }
928
929 static HRESULT WINAPI recordset_GetTypeInfoCount( _Recordset *iface, UINT *count )
930 {
931 struct recordset *recordset = impl_from_Recordset( iface );
932 TRACE( "%p, %p\n", recordset, count );
933 *count = 1;
934 return S_OK;
935 }
936
937 static HRESULT WINAPI recordset_GetTypeInfo( _Recordset *iface, UINT index, LCID lcid, ITypeInfo **info )
938 {
939 struct recordset *recordset = impl_from_Recordset( iface );
940 TRACE( "%p, %u, %u, %p\n", recordset, index, lcid, info );
941 return get_typeinfo(Recordset_tid, info);
942 }
943
944 static HRESULT WINAPI recordset_GetIDsOfNames( _Recordset *iface, REFIID riid, LPOLESTR *names, UINT count,
945 LCID lcid, DISPID *dispid )
946 {
947 struct recordset *recordset = impl_from_Recordset( iface );
948 HRESULT hr;
949 ITypeInfo *typeinfo;
950
951 TRACE( "%p, %s, %p, %u, %u, %p\n", recordset, debugstr_guid(riid), names, count, lcid, dispid );
952
953 hr = get_typeinfo(Recordset_tid, &typeinfo);
954 if(SUCCEEDED(hr))
955 {
956 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispid);
957 ITypeInfo_Release(typeinfo);
958 }
959
960 return hr;
961 }
962
963 static HRESULT WINAPI recordset_Invoke( _Recordset *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
964 DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
965 {
966 struct recordset *recordset = impl_from_Recordset( iface );
967 HRESULT hr;
968 ITypeInfo *typeinfo;
969
970 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", recordset, member, debugstr_guid(riid), lcid, flags, params,
971 result, excep_info, arg_err );
972
973 hr = get_typeinfo(Recordset_tid, &typeinfo);
974 if(SUCCEEDED(hr))
975 {
976 hr = ITypeInfo_Invoke(typeinfo, &recordset->Recordset_iface, member, flags, params,
977 result, excep_info, arg_err);
978 ITypeInfo_Release(typeinfo);
979 }
980
981 return hr;
982 }
983
984 static HRESULT WINAPI recordset_get_Properties( _Recordset *iface, Properties **obj )
985 {
986 FIXME( "%p, %p\n", iface, obj );
987 return E_NOTIMPL;
988 }
989
990 static HRESULT WINAPI recordset_get_AbsolutePosition( _Recordset *iface, PositionEnum_Param *pos )
991 {
992 FIXME( "%p, %p\n", iface, pos );
993 return E_NOTIMPL;
994 }
995
996 static HRESULT WINAPI recordset_put_AbsolutePosition( _Recordset *iface, PositionEnum_Param pos )
997 {
998 FIXME( "%p, %d\n", iface, pos );
999 return E_NOTIMPL;
1000 }
1001
1002 static HRESULT WINAPI recordset_putref_ActiveConnection( _Recordset *iface, IDispatch *connection )
1003 {
1004 FIXME( "%p, %p\n", iface, connection );
1005 return E_NOTIMPL;
1006 }
1007
1008 static HRESULT WINAPI recordset_put_ActiveConnection( _Recordset *iface, VARIANT connection )
1009 {
1010 FIXME( "%p, %s\n", iface, debugstr_variant(&connection) );
1011 return E_NOTIMPL;
1012 }
1013
1014 static HRESULT WINAPI recordset_get_ActiveConnection( _Recordset *iface, VARIANT *connection )
1015 {
1016 FIXME( "%p, %p\n", iface, connection );
1017 return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI recordset_get_BOF( _Recordset *iface, VARIANT_BOOL *bof )
1021 {
1022 struct recordset *recordset = impl_from_Recordset( iface );
1023
1024 TRACE( "%p, %p\n", recordset, bof );
1025
1026 *bof = (recordset->index < 0) ? VARIANT_TRUE : VARIANT_FALSE;
1027 return S_OK;
1028 }
1029
1030 static HRESULT WINAPI recordset_get_Bookmark( _Recordset *iface, VARIANT *bookmark )
1031 {
1032 struct recordset *recordset = impl_from_Recordset( iface );
1033 TRACE( "%p, %p\n", iface, bookmark );
1034
1035 if (recordset->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed );
1036 if (recordset->index < 0) return MAKE_ADO_HRESULT( adErrNoCurrentRecord );
1037
1038 V_VT(bookmark) = VT_I4;
1039 V_I4(bookmark) = recordset->index;
1040 return S_OK;
1041 }
1042
1043 static HRESULT WINAPI recordset_put_Bookmark( _Recordset *iface, VARIANT bookmark )
1044 {
1045 struct recordset *recordset = impl_from_Recordset( iface );
1046 TRACE( "%p, %s\n", iface, debugstr_variant(&bookmark) );
1047
1048 if (recordset->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed );
1049
1050 if (V_VT(&bookmark) != VT_I4) return MAKE_ADO_HRESULT( adErrInvalidArgument );
1051
1052 recordset->index = V_I4(&bookmark);
1053 return S_OK;
1054 }
1055
1056 static HRESULT WINAPI recordset_get_CacheSize( _Recordset *iface, LONG *size )
1057 {
1058 FIXME( "%p, %p\n", iface, size );
1059 return E_NOTIMPL;
1060 }
1061
1062 static HRESULT WINAPI recordset_put_CacheSize( _Recordset *iface, LONG size )
1063 {
1064 FIXME( "%p, %d\n", iface, size );
1065 return E_NOTIMPL;
1066 }
1067
1068 static HRESULT WINAPI recordset_get_CursorType( _Recordset *iface, CursorTypeEnum *cursor_type )
1069 {
1070 struct recordset *recordset = impl_from_Recordset( iface );
1071
1072 TRACE( "%p, %p\n", iface, cursor_type );
1073
1074 *cursor_type = recordset->cursor_type;
1075 return S_OK;
1076 }
1077
1078 static HRESULT WINAPI recordset_put_CursorType( _Recordset *iface, CursorTypeEnum cursor_type )
1079 {
1080 struct recordset *recordset = impl_from_Recordset( iface );
1081
1082 TRACE( "%p, %d\n", iface, cursor_type );
1083
1084 recordset->cursor_type = cursor_type;
1085 return S_OK;
1086 }
1087
1088 static HRESULT WINAPI recordset_get_EOF( _Recordset *iface, VARIANT_BOOL *eof )
1089 {
1090 struct recordset *recordset = impl_from_Recordset( iface );
1091
1092 TRACE( "%p, %p\n", recordset, eof );
1093
1094 *eof = (!recordset->count || recordset->index >= recordset->count) ? VARIANT_TRUE : VARIANT_FALSE;
1095 return S_OK;
1096 }
1097
1098 static HRESULT WINAPI recordset_get_Fields( _Recordset *iface, Fields **obj )
1099 {
1100 struct recordset *recordset = impl_from_Recordset( iface );
1101 HRESULT hr;
1102
1103 TRACE( "%p, %p\n", recordset, obj );
1104
1105 if (recordset->fields)
1106 {
1107 /* yes, this adds a reference to the recordset instead of the fields object */
1108 _Recordset_AddRef( &recordset->Recordset_iface );
1109 recordset->fields->recordset = recordset;
1110 *obj = &recordset->fields->Fields_iface;
1111 return S_OK;
1112 }
1113
1114 if ((hr = fields_create( recordset, &recordset->fields )) != S_OK) return hr;
1115
1116 *obj = &recordset->fields->Fields_iface;
1117 return S_OK;
1118 }
1119
1120 static HRESULT WINAPI recordset_get_LockType( _Recordset *iface, LockTypeEnum *lock_type )
1121 {
1122 FIXME( "%p, %p\n", iface, lock_type );
1123 return E_NOTIMPL;
1124 }
1125
1126 static HRESULT WINAPI recordset_put_LockType( _Recordset *iface, LockTypeEnum lock_type )
1127 {
1128 FIXME( "%p, %d\n", iface, lock_type );
1129 return E_NOTIMPL;
1130 }
1131
1132 static HRESULT WINAPI recordset_get_MaxRecords( _Recordset *iface, LONG *max_records )
1133 {
1134 FIXME( "%p, %p\n", iface, max_records );
1135 return E_NOTIMPL;
1136 }
1137
1138 static HRESULT WINAPI recordset_put_MaxRecords( _Recordset *iface, LONG max_records )
1139 {
1140 FIXME( "%p, %d\n", iface, max_records );
1141 return E_NOTIMPL;
1142 }
1143
1144 static HRESULT WINAPI recordset_get_RecordCount( _Recordset *iface, LONG *count )
1145 {
1146 struct recordset *recordset = impl_from_Recordset( iface );
1147
1148 TRACE( "%p, %p\n", recordset, count );
1149
1150 *count = recordset->count;
1151 return S_OK;
1152 }
1153
1154 static HRESULT WINAPI recordset_putref_Source( _Recordset *iface, IDispatch *source )
1155 {
1156 FIXME( "%p, %p\n", iface, source );
1157 return E_NOTIMPL;
1158 }
1159
1160 static HRESULT WINAPI recordset_put_Source( _Recordset *iface, BSTR source )
1161 {
1162 FIXME( "%p, %s\n", iface, debugstr_w(source) );
1163 return E_NOTIMPL;
1164 }
1165
1166 static HRESULT WINAPI recordset_get_Source( _Recordset *iface, VARIANT *source )
1167 {
1168 FIXME( "%p, %p\n", iface, source );
1169 return E_NOTIMPL;
1170 }
1171
1172 static BOOL resize_recordset( struct recordset *recordset, ULONG row_count )
1173 {
1174 ULONG row_size = get_column_count( recordset ) * sizeof(*recordset->data);
1175
1176 if (row_count > recordset->allocated)
1177 {
1178 VARIANT *tmp;
1179 ULONG count = max( row_count, recordset->allocated * 2 );
1180 if (!(tmp = heap_realloc_zero( recordset->data, count * row_size ))) return FALSE;
1181 recordset->data = tmp;
1182 recordset->allocated = count;
1183 }
1184
1185 recordset->count = row_count;
1186 return TRUE;
1187 }
1188
1189 static HRESULT WINAPI recordset_AddNew( _Recordset *iface, VARIANT field_list, VARIANT values )
1190 {
1191 struct recordset *recordset = impl_from_Recordset( iface );
1192
1193 TRACE( "%p, %s, %s\n", recordset, debugstr_variant(&field_list), debugstr_variant(&values) );
1194 FIXME( "ignoring field list and values\n" );
1195
1196 if (recordset->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed );
1197
1198 if (!resize_recordset( recordset, recordset->count + 1 )) return E_OUTOFMEMORY;
1199 recordset->index++;
1200 return S_OK;
1201 }
1202
1203 static HRESULT WINAPI recordset_CancelUpdate( _Recordset *iface )
1204 {
1205 FIXME( "%p\n", iface );
1206 return E_NOTIMPL;
1207 }
1208
1209 static HRESULT WINAPI recordset_Close( _Recordset *iface )
1210 {
1211 struct recordset *recordset = impl_from_Recordset( iface );
1212
1213 TRACE( "%p\n", recordset );
1214
1215 if (recordset->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed );
1216
1217 close_recordset( recordset );
1218 recordset->state = adStateClosed;
1219 return S_OK;
1220 }
1221
1222 static HRESULT WINAPI recordset_Delete( _Recordset *iface, AffectEnum affect_records )
1223 {
1224 FIXME( "%p, %u\n", iface, affect_records );
1225 return E_NOTIMPL;
1226 }
1227
1228 static HRESULT WINAPI recordset_GetRows( _Recordset *iface, LONG rows, VARIANT start, VARIANT fields, VARIANT *var )
1229 {
1230 FIXME( "%p, %d, %s, %s, %p\n", iface, rows, debugstr_variant(&start), debugstr_variant(&fields), var );
1231 return E_NOTIMPL;
1232 }
1233
1234 static HRESULT WINAPI recordset_Move( _Recordset *iface, LONG num_records, VARIANT start )
1235 {
1236 FIXME( "%p, %d, %s\n", iface, num_records, debugstr_variant(&start) );
1237 return E_NOTIMPL;
1238 }
1239
1240 static HRESULT WINAPI recordset_MoveNext( _Recordset *iface )
1241 {
1242 struct recordset *recordset = impl_from_Recordset( iface );
1243
1244 TRACE( "%p\n", recordset );
1245
1246 if (recordset->index < recordset->count) recordset->index++;
1247 return S_OK;
1248 }
1249
1250 static HRESULT WINAPI recordset_MovePrevious( _Recordset *iface )
1251 {
1252 struct recordset *recordset = impl_from_Recordset( iface );
1253
1254 TRACE( "%p\n", recordset );
1255
1256 if (recordset->index >= 0) recordset->index--;
1257 return S_OK;
1258 }
1259
1260 static HRESULT WINAPI recordset_MoveFirst( _Recordset *iface )
1261 {
1262 struct recordset *recordset = impl_from_Recordset( iface );
1263
1264 TRACE( "%p\n", recordset );
1265
1266 recordset->index = 0;
1267 return S_OK;
1268 }
1269
1270 static HRESULT WINAPI recordset_MoveLast( _Recordset *iface )
1271 {
1272 struct recordset *recordset = impl_from_Recordset( iface );
1273
1274 TRACE( "%p\n", recordset );
1275
1276 recordset->index = (recordset->count > 0) ? recordset->count - 1 : 0;
1277 return S_OK;
1278 }
1279
1280 static HRESULT WINAPI recordset_Open( _Recordset *iface, VARIANT source, VARIANT active_connection,
1281 CursorTypeEnum cursor_type, LockTypeEnum lock_type, LONG options )
1282 {
1283 struct recordset *recordset = impl_from_Recordset( iface );
1284 ADOConnectionConstruction15 *construct;
1285 IUnknown *session;
1286 ICommandText *command_text;
1287 DBROWCOUNT affected;
1288 IUnknown *rowset;
1289 HRESULT hr;
1290
1291 FIXME( "%p, %s, %s, %d, %d, %d Semi-stub\n", recordset, debugstr_variant(&source), debugstr_variant(&active_connection),
1292 cursor_type, lock_type, options );
1293
1294 if (recordset->state == adStateOpen) return MAKE_ADO_HRESULT( adErrObjectOpen );
1295
1296 if (recordset->fields)
1297 {
1298 recordset->state = adStateOpen;
1299 return S_OK;
1300 }
1301
1302 if (V_VT(&active_connection) != VT_DISPATCH)
1303 {
1304 FIXME("Unsupported Active connection type %d\n", V_VT(&active_connection));
1305 return MAKE_ADO_HRESULT( adErrInvalidConnection );
1306 }
1307
1308 hr = IDispatch_QueryInterface(V_DISPATCH(&active_connection), &IID_ADOConnectionConstruction15, (void**)&construct);
1309 if (FAILED(hr))
1310 return E_FAIL;
1311
1312 hr = ADOConnectionConstruction15_get_Session(construct, &session);
1313 ADOConnectionConstruction15_Release(construct);
1314 if (FAILED(hr))
1315 return E_FAIL;
1316
1317 if (V_VT(&source) != VT_BSTR)
1318 {
1319 FIXME("Unsupported source type!\n");
1320 IUnknown_Release(session);
1321 return E_FAIL;
1322 }
1323
1324 hr = create_command_text(session, V_BSTR(&source), &command_text);
1325 IUnknown_Release(session);
1326 if (FAILED(hr))
1327 return hr;
1328
1329 hr = ICommandText_Execute(command_text, NULL, &IID_IUnknown, NULL, &affected, &rowset);
1330 ICommandText_Release(command_text);
1331 if (FAILED(hr))
1332 return hr;
1333
1334 ADORecordsetConstruction_put_Rowset(&recordset->ADORecordsetConstruction_iface, rowset);
1335 recordset->cursor_type = cursor_type;
1336 recordset->state = adStateOpen;
1337
1338 IUnknown_Release(rowset);
1339
1340 return hr;
1341 }
1342
1343 static HRESULT WINAPI recordset_Requery( _Recordset *iface, LONG options )
1344 {
1345 FIXME( "%p, %d\n", iface, options );
1346 return E_NOTIMPL;
1347 }
1348
1349 static HRESULT WINAPI recordset__xResync( _Recordset *iface, AffectEnum affect_records )
1350 {
1351 FIXME( "%p, %u\n", iface, affect_records );
1352 return E_NOTIMPL;
1353 }
1354
1355 static HRESULT WINAPI recordset_Update( _Recordset *iface, VARIANT fields, VARIANT values )
1356 {
1357 FIXME( "%p, %s, %s\n", iface, debugstr_variant(&fields), debugstr_variant(&values) );
1358 return E_NOTIMPL;
1359 }
1360
1361 static HRESULT WINAPI recordset_get_AbsolutePage( _Recordset *iface, PositionEnum_Param *pos )
1362 {
1363 FIXME( "%p, %p\n", iface, pos );
1364 return E_NOTIMPL;
1365 }
1366
1367 static HRESULT WINAPI recordset_put_AbsolutePage( _Recordset *iface, PositionEnum_Param pos )
1368 {
1369 FIXME( "%p, %d\n", iface, pos );
1370 return E_NOTIMPL;
1371 }
1372
1373 static HRESULT WINAPI recordset_get_EditMode( _Recordset *iface, EditModeEnum *mode )
1374 {
1375 FIXME( "%p, %p\n", iface, mode );
1376 return E_NOTIMPL;
1377 }
1378
1379 static HRESULT WINAPI recordset_get_Filter( _Recordset *iface, VARIANT *criteria )
1380 {
1381 FIXME( "%p, %p\n", iface, criteria );
1382 return E_NOTIMPL;
1383 }
1384
1385 static HRESULT WINAPI recordset_put_Filter( _Recordset *iface, VARIANT criteria )
1386 {
1387 FIXME( "%p, %s\n", iface, debugstr_variant(&criteria) );
1388 return E_NOTIMPL;
1389 }
1390
1391 static HRESULT WINAPI recordset_get_PageCount( _Recordset *iface, LONG *count )
1392 {
1393 FIXME( "%p, %p\n", iface, count );
1394 return E_NOTIMPL;
1395 }
1396
1397 static HRESULT WINAPI recordset_get_PageSize( _Recordset *iface, LONG *size )
1398 {
1399 FIXME( "%p, %p\n", iface, size );
1400 return E_NOTIMPL;
1401 }
1402
1403 static HRESULT WINAPI recordset_put_PageSize( _Recordset *iface, LONG size )
1404 {
1405 FIXME( "%p, %d\n", iface, size );
1406 return E_NOTIMPL;
1407 }
1408
1409 static HRESULT WINAPI recordset_get_Sort( _Recordset *iface, BSTR *criteria )
1410 {
1411 FIXME( "%p, %p\n", iface, criteria );
1412 return E_NOTIMPL;
1413 }
1414
1415 static HRESULT WINAPI recordset_put_Sort( _Recordset *iface, BSTR criteria )
1416 {
1417 FIXME( "%p, %s\n", iface, debugstr_w(criteria) );
1418 return E_NOTIMPL;
1419 }
1420
1421 static HRESULT WINAPI recordset_get_Status( _Recordset *iface, LONG *status )
1422 {
1423 FIXME( "%p, %p\n", iface, status );
1424 return E_NOTIMPL;
1425 }
1426
1427 static HRESULT WINAPI recordset_get_State( _Recordset *iface, LONG *state )
1428 {
1429 struct recordset *recordset = impl_from_Recordset( iface );
1430
1431 TRACE( "%p, %p\n", recordset, state );
1432
1433 *state = recordset->state;
1434 return S_OK;
1435 }
1436
1437 static HRESULT WINAPI recordset__xClone( _Recordset *iface, _Recordset **obj )
1438 {
1439 FIXME( "%p, %p\n", iface, obj );
1440 return E_NOTIMPL;
1441 }
1442
1443 static HRESULT WINAPI recordset_UpdateBatch( _Recordset *iface, AffectEnum affect_records )
1444 {
1445 FIXME( "%p, %u\n", iface, affect_records );
1446 return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI recordset_CancelBatch( _Recordset *iface, AffectEnum affect_records )
1450 {
1451 FIXME( "%p, %u\n", iface, affect_records );
1452 return E_NOTIMPL;
1453 }
1454
1455 static HRESULT WINAPI recordset_get_CursorLocation( _Recordset *iface, CursorLocationEnum *cursor_loc )
1456 {
1457 struct recordset *recordset = impl_from_Recordset( iface );
1458
1459 TRACE( "%p, %p\n", iface, cursor_loc );
1460
1461 *cursor_loc = recordset->cursor_location;
1462
1463 return S_OK;
1464 }
1465
1466 static HRESULT WINAPI recordset_put_CursorLocation( _Recordset *iface, CursorLocationEnum cursor_loc )
1467 {
1468 struct recordset *recordset = impl_from_Recordset( iface );
1469
1470 TRACE( "%p, %u\n", iface, cursor_loc );
1471
1472 if (recordset->state == adStateOpen) return MAKE_ADO_HRESULT( adErrObjectOpen );
1473
1474 recordset->cursor_location = cursor_loc;
1475
1476 return S_OK;
1477 }
1478
1479 static HRESULT WINAPI recordset_NextRecordset( _Recordset *iface, VARIANT *records_affected, _Recordset **record_set )
1480 {
1481 FIXME( "%p, %p, %p\n", iface, records_affected, record_set );
1482 return E_NOTIMPL;
1483 }
1484
1485 static HRESULT WINAPI recordset_Supports( _Recordset *iface, CursorOptionEnum cursor_options, VARIANT_BOOL *ret )
1486 {
1487 FIXME( "%p, %08x, %p\n", iface, cursor_options, ret );
1488 return E_NOTIMPL;
1489 }
1490
1491 static HRESULT WINAPI recordset_get_Collect( _Recordset *iface, VARIANT index, VARIANT *var )
1492 {
1493 FIXME( "%p, %s, %p\n", iface, debugstr_variant(&index), var );
1494 return E_NOTIMPL;
1495 }
1496
1497 static HRESULT WINAPI recordset_put_Collect( _Recordset *iface, VARIANT index, VARIANT var )
1498 {
1499 FIXME( "%p, %s, %s\n", iface, debugstr_variant(&index), debugstr_variant(&var) );
1500 return E_NOTIMPL;
1501 }
1502
1503 static HRESULT WINAPI recordset_get_MarshalOptions( _Recordset *iface, MarshalOptionsEnum *options )
1504 {
1505 FIXME( "%p, %p\n", iface, options );
1506 return E_NOTIMPL;
1507 }
1508
1509 static HRESULT WINAPI recordset_put_MarshalOptions( _Recordset *iface, MarshalOptionsEnum options )
1510 {
1511 FIXME( "%p, %u\n", iface, options );
1512 return E_NOTIMPL;
1513 }
1514
1515 static HRESULT WINAPI recordset_Find( _Recordset *iface, BSTR criteria, LONG skip_records,
1516 SearchDirectionEnum search_direction, VARIANT start )
1517 {
1518 FIXME( "%p, %s, %d, %d, %s\n", iface, debugstr_w(criteria), skip_records, search_direction,
1519 debugstr_variant(&start) );
1520 return E_NOTIMPL;
1521 }
1522
1523 static HRESULT WINAPI recordset_Cancel( _Recordset *iface )
1524 {
1525 FIXME( "%p\n", iface );
1526 return E_NOTIMPL;
1527 }
1528
1529 static HRESULT WINAPI recordset_get_DataSource( _Recordset *iface, IUnknown **data_source )
1530 {
1531 FIXME( "%p, %p\n", iface, data_source );
1532 return E_NOTIMPL;
1533 }
1534
1535 static HRESULT WINAPI recordset_putref_DataSource( _Recordset *iface, IUnknown *data_source )
1536 {
1537 FIXME( "%p, %p\n", iface, data_source );
1538 return E_NOTIMPL;
1539 }
1540
1541 static HRESULT WINAPI recordset__xSave( _Recordset *iface, BSTR filename, PersistFormatEnum persist_format )
1542 {
1543 FIXME( "%p, %s, %u\n", iface, debugstr_w(filename), persist_format );
1544 return E_NOTIMPL;
1545 }
1546
1547 static HRESULT WINAPI recordset_get_ActiveCommand( _Recordset *iface, IDispatch **cmd )
1548 {
1549 FIXME( "%p, %p\n", iface, cmd );
1550 return E_NOTIMPL;
1551 }
1552
1553 static HRESULT WINAPI recordset_put_StayInSync( _Recordset *iface, VARIANT_BOOL stay_in_sync )
1554 {
1555 FIXME( "%p, %d\n", iface, stay_in_sync );
1556 return E_NOTIMPL;
1557 }
1558
1559 static HRESULT WINAPI recordset_get_StayInSync( _Recordset *iface, VARIANT_BOOL *stay_in_sync )
1560 {
1561 FIXME( "%p, %p\n", iface, stay_in_sync );
1562 return E_NOTIMPL;
1563 }
1564
1565 static HRESULT WINAPI recordset_GetString( _Recordset *iface, StringFormatEnum string_format, LONG num_rows,
1566 BSTR column_delimiter, BSTR row_delimiter, BSTR null_expr,
1567 BSTR *ret_string )
1568 {
1569 FIXME( "%p, %u, %d, %s, %s, %s, %p\n", iface, string_format, num_rows, debugstr_w(column_delimiter),
1570 debugstr_w(row_delimiter), debugstr_w(null_expr), ret_string );
1571 return E_NOTIMPL;
1572 }
1573
1574 static HRESULT WINAPI recordset_get_DataMember( _Recordset *iface, BSTR *data_member )
1575 {
1576 FIXME( "%p, %p\n", iface, data_member );
1577 return E_NOTIMPL;
1578 }
1579
1580 static HRESULT WINAPI recordset_put_DataMember( _Recordset *iface, BSTR data_member )
1581 {
1582 FIXME( "%p, %s\n", iface, debugstr_w(data_member) );
1583 return E_NOTIMPL;
1584 }
1585
1586 static HRESULT WINAPI recordset_CompareBookmarks( _Recordset *iface, VARIANT bookmark1, VARIANT bookmark2, CompareEnum *compare )
1587 {
1588 FIXME( "%p, %s, %s, %p\n", iface, debugstr_variant(&bookmark1), debugstr_variant(&bookmark2), compare );
1589 return E_NOTIMPL;
1590 }
1591
1592 static HRESULT WINAPI recordset_Clone( _Recordset *iface, LockTypeEnum lock_type, _Recordset **obj )
1593 {
1594 FIXME( "%p, %d, %p\n", iface, lock_type, obj );
1595 return E_NOTIMPL;
1596 }
1597
1598 static HRESULT WINAPI recordset_Resync( _Recordset *iface, AffectEnum affect_records, ResyncEnum resync_values )
1599 {
1600 FIXME( "%p, %u, %u\n", iface, affect_records, resync_values );
1601 return E_NOTIMPL;
1602 }
1603
1604 static HRESULT WINAPI recordset_Seek( _Recordset *iface, VARIANT key_values, SeekEnum seek_option )
1605 {
1606 FIXME( "%p, %s, %u\n", iface, debugstr_variant(&key_values), seek_option );
1607 return E_NOTIMPL;
1608 }
1609
1610 static HRESULT WINAPI recordset_put_Index( _Recordset *iface, BSTR index )
1611 {
1612 FIXME( "%p, %s\n", iface, debugstr_w(index) );
1613 return E_NOTIMPL;
1614 }
1615
1616 static HRESULT WINAPI recordset_get_Index( _Recordset *iface, BSTR *index )
1617 {
1618 FIXME( "%p, %p\n", iface, index );
1619 return E_NOTIMPL;
1620 }
1621
1622 static HRESULT WINAPI recordset_Save( _Recordset *iface, VARIANT destination, PersistFormatEnum persist_format )
1623 {
1624 FIXME( "%p, %s, %u\n", iface, debugstr_variant(&destination), persist_format );
1625 return E_NOTIMPL;
1626 }
1627
1628 static const struct _RecordsetVtbl recordset_vtbl =
1629 {
1630 recordset_QueryInterface,
1631 recordset_AddRef,
1632 recordset_Release,
1633 recordset_GetTypeInfoCount,
1634 recordset_GetTypeInfo,
1635 recordset_GetIDsOfNames,
1636 recordset_Invoke,
1637 recordset_get_Properties,
1638 recordset_get_AbsolutePosition,
1639 recordset_put_AbsolutePosition,
1640 recordset_putref_ActiveConnection,
1641 recordset_put_ActiveConnection,
1642 recordset_get_ActiveConnection,
1643 recordset_get_BOF,
1644 recordset_get_Bookmark,
1645 recordset_put_Bookmark,
1646 recordset_get_CacheSize,
1647 recordset_put_CacheSize,
1648 recordset_get_CursorType,
1649 recordset_put_CursorType,
1650 recordset_get_EOF,
1651 recordset_get_Fields,
1652 recordset_get_LockType,
1653 recordset_put_LockType,
1654 recordset_get_MaxRecords,
1655 recordset_put_MaxRecords,
1656 recordset_get_RecordCount,
1657 recordset_putref_Source,
1658 recordset_put_Source,
1659 recordset_get_Source,
1660 recordset_AddNew,
1661 recordset_CancelUpdate,
1662 recordset_Close,
1663 recordset_Delete,
1664 recordset_GetRows,
1665 recordset_Move,
1666 recordset_MoveNext,
1667 recordset_MovePrevious,
1668 recordset_MoveFirst,
1669 recordset_MoveLast,
1670 recordset_Open,
1671 recordset_Requery,
1672 recordset__xResync,
1673 recordset_Update,
1674 recordset_get_AbsolutePage,
1675 recordset_put_AbsolutePage,
1676 recordset_get_EditMode,
1677 recordset_get_Filter,
1678 recordset_put_Filter,
1679 recordset_get_PageCount,
1680 recordset_get_PageSize,
1681 recordset_put_PageSize,
1682 recordset_get_Sort,
1683 recordset_put_Sort,
1684 recordset_get_Status,
1685 recordset_get_State,
1686 recordset__xClone,
1687 recordset_UpdateBatch,
1688 recordset_CancelBatch,
1689 recordset_get_CursorLocation,
1690 recordset_put_CursorLocation,
1691 recordset_NextRecordset,
1692 recordset_Supports,
1693 recordset_get_Collect,
1694 recordset_put_Collect,
1695 recordset_get_MarshalOptions,
1696 recordset_put_MarshalOptions,
1697 recordset_Find,
1698 recordset_Cancel,
1699 recordset_get_DataSource,
1700 recordset_putref_DataSource,
1701 recordset__xSave,
1702 recordset_get_ActiveCommand,
1703 recordset_put_StayInSync,
1704 recordset_get_StayInSync,
1705 recordset_GetString,
1706 recordset_get_DataMember,
1707 recordset_put_DataMember,
1708 recordset_CompareBookmarks,
1709 recordset_Clone,
1710 recordset_Resync,
1711 recordset_Seek,
1712 recordset_put_Index,
1713 recordset_get_Index,
1714 recordset_Save
1715 };
1716
1717 static inline struct recordset *recordset_from_ISupportErrorInfo( ISupportErrorInfo *iface )
1718 {
1719 return CONTAINING_RECORD( iface, struct recordset, ISupportErrorInfo_iface );
1720 }
1721
1722 static HRESULT WINAPI recordset_supporterrorinfo_QueryInterface( ISupportErrorInfo *iface, REFIID riid, void **obj )
1723 {
1724 struct recordset *recordset = recordset_from_ISupportErrorInfo( iface );
1725 return _Recordset_QueryInterface( &recordset->Recordset_iface, riid, obj );
1726 }
1727
1728 static ULONG WINAPI recordset_supporterrorinfo_AddRef( ISupportErrorInfo *iface )
1729 {
1730 struct recordset *recordset = recordset_from_ISupportErrorInfo( iface );
1731 return _Recordset_AddRef( &recordset->Recordset_iface );
1732 }
1733
1734 static ULONG WINAPI recordset_supporterrorinfo_Release( ISupportErrorInfo *iface )
1735 {
1736 struct recordset *recordset = recordset_from_ISupportErrorInfo( iface );
1737 return _Recordset_Release( &recordset->Recordset_iface );
1738 }
1739
1740 static HRESULT WINAPI recordset_supporterrorinfo_InterfaceSupportsErrorInfo( ISupportErrorInfo *iface, REFIID riid )
1741 {
1742 struct recordset *recordset = recordset_from_ISupportErrorInfo( iface );
1743 FIXME( "%p, %s\n", recordset, debugstr_guid(riid) );
1744 return S_FALSE;
1745 }
1746
1747 static const ISupportErrorInfoVtbl recordset_supporterrorinfo_vtbl =
1748 {
1749 recordset_supporterrorinfo_QueryInterface,
1750 recordset_supporterrorinfo_AddRef,
1751 recordset_supporterrorinfo_Release,
1752 recordset_supporterrorinfo_InterfaceSupportsErrorInfo
1753 };
1754
1755 static HRESULT WINAPI rsconstruction_QueryInterface(ADORecordsetConstruction *iface,
1756 REFIID riid, void **obj)
1757 {
1758 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1759 return _Recordset_QueryInterface( &recordset->Recordset_iface, riid, obj );
1760 }
1761
1762 static ULONG WINAPI rsconstruction_AddRef(ADORecordsetConstruction *iface)
1763 {
1764 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1765 return _Recordset_AddRef( &recordset->Recordset_iface );
1766 }
1767
1768 static ULONG WINAPI rsconstruction_Release(ADORecordsetConstruction *iface)
1769 {
1770 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1771 return _Recordset_Release( &recordset->Recordset_iface );
1772 }
1773
1774 static HRESULT WINAPI rsconstruction_GetTypeInfoCount(ADORecordsetConstruction *iface, UINT *pctinfo)
1775 {
1776 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1777 TRACE( "%p, %p\n", recordset, pctinfo );
1778 *pctinfo = 1;
1779 return S_OK;
1780 }
1781
1782 static HRESULT WINAPI rsconstruction_GetTypeInfo(ADORecordsetConstruction *iface, UINT iTInfo,
1783 LCID lcid, ITypeInfo **ppTInfo)
1784 {
1785 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1786 TRACE( "%p %u %u %p\n", recordset, iTInfo, lcid, ppTInfo );
1787 return get_typeinfo(ADORecordsetConstruction_tid, ppTInfo);
1788 }
1789
1790 static HRESULT WINAPI rsconstruction_GetIDsOfNames(ADORecordsetConstruction *iface, REFIID riid,
1791 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1792 {
1793 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1794 HRESULT hr;
1795 ITypeInfo *typeinfo;
1796
1797 TRACE( "%p %s %p %u %u %p\n", recordset, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId );
1798
1799 hr = get_typeinfo(ADORecordsetConstruction_tid, &typeinfo);
1800 if(SUCCEEDED(hr))
1801 {
1802 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1803 ITypeInfo_Release(typeinfo);
1804 }
1805
1806 return hr;
1807 }
1808
1809 static HRESULT WINAPI rsconstruction_Invoke(ADORecordsetConstruction *iface, DISPID dispIdMember,
1810 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1811 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1812 {
1813 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1814 HRESULT hr;
1815 ITypeInfo *typeinfo;
1816
1817 TRACE( "%p %d %s %d %d %p %p %p %p\n", recordset, dispIdMember, debugstr_guid(riid),
1818 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
1819
1820 hr = get_typeinfo(ADORecordsetConstruction_tid, &typeinfo);
1821 if(SUCCEEDED(hr))
1822 {
1823 hr = ITypeInfo_Invoke(typeinfo, &recordset->ADORecordsetConstruction_iface, dispIdMember, wFlags,
1824 pDispParams, pVarResult, pExcepInfo, puArgErr);
1825 ITypeInfo_Release(typeinfo);
1826 }
1827
1828 return hr;
1829 }
1830
1831 static HRESULT WINAPI rsconstruction_get_Rowset(ADORecordsetConstruction *iface, IUnknown **row_set)
1832 {
1833 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1834 HRESULT hr;
1835
1836 TRACE( "%p, %p\n", recordset, row_set );
1837
1838 hr = IRowset_QueryInterface(recordset->row_set, &IID_IUnknown, (void**)row_set);
1839 if ( FAILED(hr) ) return E_FAIL;
1840
1841 return S_OK;
1842 }
1843
1844 static HRESULT WINAPI rsconstruction_put_Rowset(ADORecordsetConstruction *iface, IUnknown *unk)
1845 {
1846 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1847 HRESULT hr;
1848 IRowset *rowset;
1849
1850 TRACE( "%p, %p\n", recordset, unk );
1851
1852 hr = IUnknown_QueryInterface(unk, &IID_IRowset, (void**)&rowset);
1853 if ( FAILED(hr) ) return E_FAIL;
1854
1855 if ( recordset->row_set ) IRowset_Release( recordset->row_set );
1856 recordset->row_set = rowset;
1857
1858 return S_OK;
1859 }
1860
1861 static HRESULT WINAPI rsconstruction_get_Chapter(ADORecordsetConstruction *iface, LONG *chapter)
1862 {
1863 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1864 FIXME( "%p, %p\n", recordset, chapter );
1865 return E_NOTIMPL;
1866 }
1867
1868 static HRESULT WINAPI rsconstruction_put_Chapter(ADORecordsetConstruction *iface, LONG chapter)
1869 {
1870 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1871 FIXME( "%p, %d\n", recordset, chapter );
1872 return E_NOTIMPL;
1873 }
1874
1875 static HRESULT WINAPI rsconstruction_get_RowPosition(ADORecordsetConstruction *iface, IUnknown **row_pos)
1876 {
1877 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1878 FIXME( "%p, %p\n", recordset, row_pos );
1879 return E_NOTIMPL;
1880 }
1881
1882 static HRESULT WINAPI rsconstruction_put_RowPosition(ADORecordsetConstruction *iface, IUnknown *row_pos)
1883 {
1884 struct recordset *recordset = impl_from_ADORecordsetConstruction( iface );
1885 FIXME( "%p, %p\n", recordset, row_pos );
1886 return E_NOTIMPL;
1887 }
1888
1889 static const ADORecordsetConstructionVtbl rsconstruction_vtbl =
1890 {
1891 rsconstruction_QueryInterface,
1892 rsconstruction_AddRef,
1893 rsconstruction_Release,
1894 rsconstruction_GetTypeInfoCount,
1895 rsconstruction_GetTypeInfo,
1896 rsconstruction_GetIDsOfNames,
1897 rsconstruction_Invoke,
1898 rsconstruction_get_Rowset,
1899 rsconstruction_put_Rowset,
1900 rsconstruction_get_Chapter,
1901 rsconstruction_put_Chapter,
1902 rsconstruction_get_RowPosition,
1903 rsconstruction_put_RowPosition
1904 };
1905
1906 HRESULT Recordset_create( void **obj )
1907 {
1908 struct recordset *recordset;
1909
1910 if (!(recordset = heap_alloc_zero( sizeof(*recordset) ))) return E_OUTOFMEMORY;
1911 recordset->Recordset_iface.lpVtbl = &recordset_vtbl;
1912 recordset->ISupportErrorInfo_iface.lpVtbl = &recordset_supporterrorinfo_vtbl;
1913 recordset->ADORecordsetConstruction_iface.lpVtbl = &rsconstruction_vtbl;
1914 recordset->refs = 1;
1915 recordset->index = -1;
1916 recordset->cursor_location = adUseServer;
1917 recordset->cursor_type = adOpenForwardOnly;
1918 recordset->row_set = NULL;
1919
1920 *obj = &recordset->Recordset_iface;
1921 TRACE( "returning iface %p\n", *obj );
1922 return S_OK;
1923 }
Zebediah Figura's local tree