dlls/msado15/recordset.c

   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 }