git.oblomov.eu Git - wine/blob - dlls/oledb32/convert.c

   1 /* OLE DB Conversion library
   2  *
   3  * Copyright 2009 Huw Davies
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24 #define NONAMELESSSTRUCT
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "ole2.h"
  30 #include "msdadc.h"
  31 #include "oledberr.h"
  32
  33 #include "oledb_private.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  38
  39 typedef struct
  40 {
  41     const struct IDataConvertVtbl *lpVtbl;
  42     const struct IDCInfoVtbl *lpDCInfoVtbl;
  43
  44     LONG ref;
  45
  46     UINT version; /* Set by IDCInfo_SetInfo */
  47 } convert;
  48
  49 static inline convert *impl_from_IDataConvert(IDataConvert *iface)
  50 {
  51     return (convert *)((char*)iface - FIELD_OFFSET(convert, lpVtbl));
  52 }
  53
  54 static inline convert *impl_from_IDCInfo(IDCInfo *iface)
  55 {
  56     return (convert *)((char*)iface - FIELD_OFFSET(convert, lpDCInfoVtbl));
  57 }
  58
  59 static HRESULT WINAPI convert_QueryInterface(IDataConvert* iface,
  60                                              REFIID riid,
  61                                              void **obj)
  62 {
  63     convert *This = impl_from_IDataConvert(iface);
  64     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
  65
  66     *obj = NULL;
  67
  68     if(IsEqualIID(riid, &IID_IUnknown) ||
  69        IsEqualIID(riid, &IID_IDataConvert))
  70     {
  71         *obj = iface;
  72     }
  73     else if(IsEqualIID(riid, &IID_IDCInfo))
  74     {
  75         *obj = &This->lpDCInfoVtbl;
  76     }
  77     else
  78     {
  79         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  80         return E_NOINTERFACE;
  81     }
  82
  83     IDataConvert_AddRef(iface);
  84     return S_OK;
  85 }
  86
  87
  88 static ULONG WINAPI convert_AddRef(IDataConvert* iface)
  89 {
  90     convert *This = impl_from_IDataConvert(iface);
  91     TRACE("(%p)\n", This);
  92
  93     return InterlockedIncrement(&This->ref);
  94 }
  95
  96
  97 static ULONG WINAPI convert_Release(IDataConvert* iface)
  98 {
  99     convert *This = impl_from_IDataConvert(iface);
 100     LONG ref;
 101
 102     TRACE("(%p)\n", This);
 103
 104     ref = InterlockedDecrement(&This->ref);
 105     if(ref == 0)
 106     {
 107         HeapFree(GetProcessHeap(), 0, This);
 108     }
 109
 110     return ref;
 111 }
 112
 113 static int get_length(DBTYPE type)
 114 {
 115     switch(type)
 116     {
 117     case DBTYPE_I1:
 118     case DBTYPE_UI1:
 119         return 1;
 120     case DBTYPE_I2:
 121     case DBTYPE_UI2:
 122         return 2;
 123     case DBTYPE_I4:
 124     case DBTYPE_UI4:
 125         return 4;
 126     case DBTYPE_I8:
 127     case DBTYPE_UI8:
 128         return 8;
 129     case DBTYPE_BSTR:
 130         return sizeof(BSTR);
 131     case DBTYPE_WSTR:
 132     case DBTYPE_BYREF | DBTYPE_WSTR:
 133         return 0;
 134     default:
 135         FIXME("Unhandled type %04x\n", type);
 136         return 0;
 137     }
 138 }
 139
 140 static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
 141                                           DBTYPE src_type, DBTYPE dst_type,
 142                                           DBLENGTH src_len, DBLENGTH *dst_len,
 143                                           void *src, void *dst,
 144                                           DBLENGTH dst_max_len,
 145                                           DBSTATUS src_status, DBSTATUS *dst_status,
 146                                           BYTE precision, BYTE scale,
 147                                           DBDATACONVERT flags)
 148 {
 149     convert *This = impl_from_IDataConvert(iface);
 150     HRESULT hr;
 151
 152     TRACE("(%p)->(%d, %d, %d, %p, %p, %p, %d, %d, %p, %d, %d, %x)\n", This,
 153           src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
 154           src_status, dst_status, precision, scale, flags);
 155
 156     *dst_len = get_length(dst_type);
 157     *dst_status = DBSTATUS_E_BADACCESSOR;
 158
 159     if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
 160     {
 161         return DB_E_UNSUPPORTEDCONVERSION;
 162     }
 163
 164     if(src_type == DBTYPE_STR)
 165     {
 166         BSTR b;
 167         DWORD len;
 168
 169         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 170             len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
 171         else
 172             len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
 173         b = SysAllocStringLen(NULL, len);
 174         if(!b) return E_OUTOFMEMORY;
 175         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 176             MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
 177         else
 178             MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
 179
 180         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 181                                       &b, dst, dst_max_len, src_status, dst_status,
 182                                       precision, scale, flags);
 183
 184         SysFreeString(b);
 185         return hr;
 186     }
 187
 188     if(src_type == DBTYPE_WSTR)
 189     {
 190         BSTR b;
 191
 192         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 193             b = SysAllocString(src);
 194         else
 195             b = SysAllocStringLen(src, src_len / 2);
 196         if(!b) return E_OUTOFMEMORY;
 197         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 198                                       &b, dst, dst_max_len, src_status, dst_status,
 199                                       precision, scale, flags);
 200         SysFreeString(b);
 201         return hr;
 202     }
 203
 204     switch(dst_type)
 205     {
 206     case DBTYPE_I2:
 207     {
 208         signed short *d = dst;
 209         switch(src_type)
 210         {
 211         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 212         case DBTYPE_I2:          *d = *(signed short*)src; hr = S_OK;            break;
 213         case DBTYPE_I4:          hr = VarI2FromI4(*(signed int*)src, d);         break;
 214         case DBTYPE_R4:          hr = VarI2FromR4(*(FLOAT*)src, d);              break;
 215         case DBTYPE_R8:          hr = VarI2FromR8(*(double*)src, d);             break;
 216         case DBTYPE_CY:          hr = VarI2FromCy(*(CY*)src, d);                 break;
 217         case DBTYPE_DATE:        hr = VarI2FromDate(*(DATE*)src, d);             break;
 218         case DBTYPE_BSTR:        hr = VarI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 219         case DBTYPE_BOOL:        hr = VarI2FromBool(*(VARIANT_BOOL*)src, d);     break;
 220         case DBTYPE_DECIMAL:     hr = VarI2FromDec((DECIMAL*)src, d);            break;
 221         case DBTYPE_I1:          hr = VarI2FromI1(*(signed char*)src, d);        break;
 222         case DBTYPE_UI1:         hr = VarI2FromUI1(*(BYTE*)src, d);              break;
 223         case DBTYPE_UI2:         hr = VarI2FromUI2(*(WORD*)src, d);              break;
 224         case DBTYPE_UI4:         hr = VarI2FromUI4(*(DWORD*)src, d);             break;
 225         case DBTYPE_I8:          hr = VarI2FromI8(*(LONGLONG*)src, d);           break;
 226         case DBTYPE_UI8:         hr = VarI2FromUI8(*(ULONGLONG*)src, d);         break;
 227         default: FIXME("Unimplemented conversion %04x -> I2\n", src_type); return E_NOTIMPL;
 228         }
 229         break;
 230     }
 231
 232     case DBTYPE_I4:
 233     {
 234         signed int *d = dst;
 235         switch(src_type)
 236         {
 237         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 238         case DBTYPE_I2:          hr = VarI4FromI2(*(signed short*)src, d);       break;
 239         case DBTYPE_I4:          *d = *(signed int*)src; hr = S_OK;              break;
 240         case DBTYPE_R4:          hr = VarI4FromR4(*(FLOAT*)src, d);              break;
 241         case DBTYPE_R8:          hr = VarI4FromR8(*(double*)src, d);             break;
 242         case DBTYPE_CY:          hr = VarI4FromCy(*(CY*)src, d);                 break;
 243         case DBTYPE_DATE:        hr = VarI4FromDate(*(DATE*)src, d);             break;
 244         case DBTYPE_BSTR:        hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 245         case DBTYPE_BOOL:        hr = VarI4FromBool(*(VARIANT_BOOL*)src, d);     break;
 246         case DBTYPE_DECIMAL:     hr = VarI4FromDec((DECIMAL*)src, d);            break;
 247         case DBTYPE_I1:          hr = VarI4FromI1(*(signed char*)src, d);        break;
 248         case DBTYPE_UI1:         hr = VarI4FromUI1(*(BYTE*)src, d);              break;
 249         case DBTYPE_UI2:         hr = VarI4FromUI2(*(WORD*)src, d);              break;
 250         case DBTYPE_UI4:         hr = VarI4FromUI4(*(DWORD*)src, d);             break;
 251         case DBTYPE_I8:          hr = VarI4FromI8(*(LONGLONG*)src, d);           break;
 252         case DBTYPE_UI8:         hr = VarI4FromUI8(*(ULONGLONG*)src, d);         break;
 253         default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
 254         }
 255         break;
 256     }
 257
 258     case DBTYPE_BSTR:
 259     {
 260         BSTR *d = dst;
 261         switch(src_type)
 262         {
 263         case DBTYPE_EMPTY:       *d = SysAllocStringLen(NULL, 0); hr = *d ? S_OK : E_OUTOFMEMORY;      break;
 264         case DBTYPE_I2:          hr = VarBstrFromI2(*(signed short*)src, LOCALE_USER_DEFAULT, 0, d);   break;
 265         case DBTYPE_I4:          hr = VarBstrFromI4(*(signed int*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 266         case DBTYPE_R4:          hr = VarBstrFromR4(*(FLOAT*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 267         case DBTYPE_R8:          hr = VarBstrFromR8(*(double*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 268         case DBTYPE_CY:          hr = VarBstrFromCy(*(CY*)src, LOCALE_USER_DEFAULT, 0, d);             break;
 269         case DBTYPE_DATE:        hr = VarBstrFromDate(*(DATE*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 270         case DBTYPE_BSTR:        *d = SysAllocStringLen(*(BSTR*)src, SysStringLen(*(BSTR*)src)); hr = *d ? S_OK : E_OUTOFMEMORY;     break;
 271         case DBTYPE_BOOL:        hr = VarBstrFromBool(*(VARIANT_BOOL*)src, LOCALE_USER_DEFAULT, 0, d); break;
 272         case DBTYPE_DECIMAL:     hr = VarBstrFromDec((DECIMAL*)src, LOCALE_USER_DEFAULT, 0, d);        break;
 273         case DBTYPE_I1:          hr = VarBstrFromI1(*(signed char*)src, LOCALE_USER_DEFAULT, 0, d);    break;
 274         case DBTYPE_UI1:         hr = VarBstrFromUI1(*(BYTE*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 275         case DBTYPE_UI2:         hr = VarBstrFromUI2(*(WORD*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 276         case DBTYPE_UI4:         hr = VarBstrFromUI4(*(DWORD*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 277         case DBTYPE_I8:          hr = VarBstrFromI8(*(LONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);       break;
 278         case DBTYPE_UI8:         hr = VarBstrFromUI8(*(ULONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 279         default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type); return E_NOTIMPL;
 280         }
 281         break;
 282     }
 283
 284     case DBTYPE_WSTR:
 285     {
 286         BSTR b;
 287         DBLENGTH bstr_len;
 288         INT bytes_to_copy;
 289         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 290                                       src, &b, sizeof(BSTR), src_status, dst_status,
 291                                       precision, scale, flags);
 292         if(hr != S_OK) return hr;
 293         bstr_len = SysStringLen(b);
 294         *dst_len = bstr_len * sizeof(WCHAR); /* Doesn't include size for '\0' */
 295         *dst_status = DBSTATUS_S_OK;
 296         bytes_to_copy = min(*dst_len + sizeof(WCHAR), dst_max_len);
 297         if(dst)
 298         {
 299             if(bytes_to_copy >= sizeof(WCHAR))
 300             {
 301                 memcpy(dst, b, bytes_to_copy - sizeof(WCHAR));
 302                 *((WCHAR*)dst + bytes_to_copy / sizeof(WCHAR) - 1) = 0;
 303                 if(bytes_to_copy < *dst_len + sizeof(WCHAR))
 304                     *dst_status = DBSTATUS_S_TRUNCATED;
 305             }
 306             else
 307             {
 308                 *dst_status = DBSTATUS_E_DATAOVERFLOW;
 309                 hr = DB_E_ERRORSOCCURRED;
 310             }
 311         }
 312         SysFreeString(b);
 313         return hr;
 314     }
 315
 316     case DBTYPE_BYREF | DBTYPE_WSTR:
 317     {
 318         BSTR b;
 319         WCHAR **d = dst;
 320         DBLENGTH bstr_len;
 321         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 322                                       src, &b, sizeof(BSTR), src_status, dst_status,
 323                                       precision, scale, flags);
 324         if(hr != S_OK) return hr;
 325
 326         bstr_len = SysStringLen(b) * sizeof(WCHAR);
 327         *dst_len = bstr_len; /* Doesn't include size for '\0' */
 328
 329         *d = CoTaskMemAlloc(bstr_len + sizeof(WCHAR));
 330         if(*d) memcpy(*d, b, bstr_len + sizeof(WCHAR));
 331         else hr = E_OUTOFMEMORY;
 332         SysFreeString(b);
 333         return hr;
 334     }
 335
 336     default:
 337         FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
 338         return E_NOTIMPL;
 339
 340     }
 341
 342     if(hr == DISP_E_OVERFLOW)
 343     {
 344         *dst_status = DBSTATUS_E_DATAOVERFLOW;
 345         hr = DB_E_ERRORSOCCURRED;
 346     }
 347     else if(hr == S_OK)
 348         *dst_status = DBSTATUS_S_OK;
 349
 350     return hr;
 351 }
 352
 353 static inline WORD get_dbtype_class(DBTYPE type)
 354 {
 355     switch(type)
 356     {
 357     case DBTYPE_I2:
 358     case DBTYPE_R4:
 359     case DBTYPE_R8:
 360     case DBTYPE_I1:
 361     case DBTYPE_UI1:
 362     case DBTYPE_UI2:
 363         return DBTYPE_I2;
 364
 365     case DBTYPE_I4:
 366     case DBTYPE_UI4:
 367         return DBTYPE_I4;
 368
 369     case DBTYPE_I8:
 370     case DBTYPE_UI8:
 371         return DBTYPE_I8;
 372
 373     case DBTYPE_BSTR:
 374     case DBTYPE_STR:
 375     case DBTYPE_WSTR:
 376         return DBTYPE_BSTR;
 377
 378     case DBTYPE_DBDATE:
 379     case DBTYPE_DBTIME:
 380     case DBTYPE_DBTIMESTAMP:
 381         return DBTYPE_DBDATE;
 382     }
 383     return type;
 384 }
 385
 386 /* Many src types will convert to this group of dst types */
 387 static inline BOOL common_class(WORD dst_class)
 388 {
 389     switch(dst_class)
 390     {
 391     case DBTYPE_EMPTY:
 392     case DBTYPE_NULL:
 393     case DBTYPE_I2:
 394     case DBTYPE_I4:
 395     case DBTYPE_BSTR:
 396     case DBTYPE_BOOL:
 397     case DBTYPE_VARIANT:
 398     case DBTYPE_I8:
 399     case DBTYPE_CY:
 400     case DBTYPE_DECIMAL:
 401     case DBTYPE_NUMERIC:
 402         return TRUE;
 403     }
 404     return FALSE;
 405 }
 406
 407 static inline BOOL array_type(DBTYPE type)
 408 {
 409     return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
 410 }
 411
 412 static HRESULT WINAPI convert_CanConvert(IDataConvert* iface,
 413                                          DBTYPE src_type, DBTYPE dst_type)
 414 {
 415     convert *This = impl_from_IDataConvert(iface);
 416     DBTYPE src_base_type = src_type & 0x1ff;
 417     DBTYPE dst_base_type = dst_type & 0x1ff;
 418     WORD dst_class = get_dbtype_class(dst_base_type);
 419
 420     TRACE("(%p)->(%d, %d)\n", This, src_type, dst_type);
 421
 422     if(src_type & DBTYPE_VECTOR || dst_type & DBTYPE_VECTOR) return S_FALSE;
 423
 424     if(src_type & DBTYPE_ARRAY)
 425     {
 426         if(!array_type(src_base_type)) return S_FALSE;
 427         if(dst_type & DBTYPE_ARRAY)
 428         {
 429             if(src_type == dst_type) return S_OK;
 430             return S_FALSE;
 431         }
 432         if(dst_type == DBTYPE_VARIANT) return S_OK;
 433         return S_FALSE;
 434     }
 435
 436     if(dst_type & DBTYPE_ARRAY)
 437     {
 438         if(!array_type(dst_base_type)) return S_FALSE;
 439         if(src_type == DBTYPE_IDISPATCH || src_type == DBTYPE_VARIANT) return S_OK;
 440         return S_FALSE;
 441     }
 442
 443     if(dst_type & DBTYPE_BYREF)
 444         if(dst_base_type != DBTYPE_BYTES && dst_base_type != DBTYPE_STR && dst_base_type != DBTYPE_WSTR)
 445             return S_FALSE;
 446
 447     switch(get_dbtype_class(src_base_type))
 448     {
 449     case DBTYPE_EMPTY:
 450         if(common_class(dst_class)) return S_OK;
 451         switch(dst_class)
 452         {
 453         case DBTYPE_DATE:
 454         case DBTYPE_GUID:
 455             return S_OK;
 456         default:
 457             if(dst_base_type == DBTYPE_DBTIMESTAMP) return S_OK;
 458             return S_FALSE;
 459         }
 460
 461     case DBTYPE_NULL:
 462         switch(dst_base_type)
 463         {
 464         case DBTYPE_NULL:
 465         case DBTYPE_VARIANT: return S_OK;
 466         default: return S_FALSE;
 467         }
 468
 469     case DBTYPE_I4:
 470         if(dst_base_type == DBTYPE_BYTES) return S_OK;
 471         /* fall through */
 472     case DBTYPE_I2:
 473         if(dst_base_type == DBTYPE_DATE) return S_OK;
 474         /* fall through */
 475     case DBTYPE_DECIMAL:
 476         if(common_class(dst_class)) return S_OK;
 477         if(dst_class == DBTYPE_DBDATE) return S_OK;
 478         return S_FALSE;
 479
 480     case DBTYPE_BOOL:
 481         if(dst_base_type == DBTYPE_DATE) return S_OK;
 482     case DBTYPE_NUMERIC:
 483     case DBTYPE_CY:
 484         if(common_class(dst_class)) return S_OK;
 485         return S_FALSE;
 486
 487     case DBTYPE_I8:
 488         if(common_class(dst_class)) return S_OK;
 489         if(dst_base_type == DBTYPE_BYTES) return S_OK;
 490         return S_FALSE;
 491
 492     case DBTYPE_DATE:
 493         switch(dst_class)
 494         {
 495         case DBTYPE_EMPTY:
 496         case DBTYPE_NULL:
 497         case DBTYPE_I2:
 498         case DBTYPE_I4:
 499         case DBTYPE_BSTR:
 500         case DBTYPE_BOOL:
 501         case DBTYPE_VARIANT:
 502         case DBTYPE_I8:
 503         case DBTYPE_DATE:
 504         case DBTYPE_DBDATE:
 505             return S_OK;
 506         default: return S_FALSE;
 507         }
 508
 509     case DBTYPE_IDISPATCH:
 510     case DBTYPE_VARIANT:
 511         switch(dst_base_type)
 512         {
 513         case DBTYPE_IDISPATCH:
 514         case DBTYPE_ERROR:
 515         case DBTYPE_IUNKNOWN:
 516             return S_OK;
 517         }
 518         /* fall through */
 519     case DBTYPE_BSTR:
 520         if(common_class(dst_class)) return S_OK;
 521         switch(dst_class)
 522         {
 523         case DBTYPE_DATE:
 524         case DBTYPE_GUID:
 525         case DBTYPE_BYTES:
 526         case DBTYPE_DBDATE:
 527             return S_OK;
 528         default: return S_FALSE;
 529         }
 530
 531     case DBTYPE_ERROR:
 532         switch(dst_base_type)
 533         {
 534         case DBTYPE_BSTR:
 535         case DBTYPE_ERROR:
 536         case DBTYPE_VARIANT:
 537         case DBTYPE_WSTR:
 538             return S_OK;
 539         default: return S_FALSE;
 540         }
 541
 542     case DBTYPE_IUNKNOWN:
 543         switch(dst_base_type)
 544         {
 545         case DBTYPE_EMPTY:
 546         case DBTYPE_NULL:
 547         case DBTYPE_IDISPATCH:
 548         case DBTYPE_VARIANT:
 549         case DBTYPE_IUNKNOWN:
 550             return S_OK;
 551         default: return S_FALSE;
 552         }
 553
 554     case DBTYPE_BYTES:
 555         if(dst_class == DBTYPE_I4 || dst_class == DBTYPE_I8) return S_OK;
 556         /* fall through */
 557     case DBTYPE_GUID:
 558         switch(dst_class)
 559         {
 560         case DBTYPE_EMPTY:
 561         case DBTYPE_NULL:
 562         case DBTYPE_BSTR:
 563         case DBTYPE_VARIANT:
 564         case DBTYPE_GUID:
 565         case DBTYPE_BYTES:
 566             return S_OK;
 567         default: return S_FALSE;
 568         }
 569
 570     case DBTYPE_DBDATE:
 571         switch(dst_class)
 572         {
 573         case DBTYPE_EMPTY:
 574         case DBTYPE_NULL:
 575         case DBTYPE_DATE:
 576         case DBTYPE_BSTR:
 577         case DBTYPE_VARIANT:
 578         case DBTYPE_DBDATE:
 579             return S_OK;
 580         default: return S_FALSE;
 581         }
 582
 583     }
 584     return S_FALSE;
 585 }
 586
 587 static HRESULT WINAPI convert_GetConversionSize(IDataConvert* iface,
 588                                                 DBTYPE wSrcType, DBTYPE wDstType,
 589                                                 DBLENGTH *pcbSrcLength, DBLENGTH *pcbDstLength,
 590                                                 void *pSrc)
 591 {
 592     convert *This = impl_from_IDataConvert(iface);
 593     FIXME("(%p)->(%d, %d, %p, %p, %p): stub\n", This, wSrcType, wDstType, pcbSrcLength, pcbDstLength, pSrc);
 594
 595     return E_NOTIMPL;
 596 }
 597
 598 static const struct IDataConvertVtbl convert_vtbl =
 599 {
 600     convert_QueryInterface,
 601     convert_AddRef,
 602     convert_Release,
 603     convert_DataConvert,
 604     convert_CanConvert,
 605     convert_GetConversionSize
 606 };
 607
 608 static HRESULT WINAPI dcinfo_QueryInterface(IDCInfo* iface, REFIID riid, void **obj)
 609 {
 610     convert *This = impl_from_IDCInfo(iface);
 611
 612     return IDataConvert_QueryInterface((IDataConvert *)This, riid, obj);
 613 }
 614
 615 static ULONG WINAPI dcinfo_AddRef(IDCInfo* iface)
 616 {
 617     convert *This = impl_from_IDCInfo(iface);
 618
 619     return IDataConvert_AddRef((IDataConvert *)This);
 620 }
 621
 622 static ULONG WINAPI dcinfo_Release(IDCInfo* iface)
 623 {
 624     convert *This = impl_from_IDCInfo(iface);
 625
 626     return IDataConvert_Release((IDataConvert *)This);
 627 }
 628
 629 static HRESULT WINAPI dcinfo_GetInfo(IDCInfo *iface, ULONG num, DCINFOTYPE types[], DCINFO **info_ptr)
 630 {
 631     convert *This = impl_from_IDCInfo(iface);
 632     ULONG i;
 633     DCINFO *infos;
 634
 635     TRACE("(%p)->(%d, %p, %p)\n", This, num, types, info_ptr);
 636
 637     *info_ptr = infos = CoTaskMemAlloc(num * sizeof(*infos));
 638     if(!infos) return E_OUTOFMEMORY;
 639
 640     for(i = 0; i < num; i++)
 641     {
 642         infos[i].eInfoType = types[i];
 643         VariantInit(&infos[i].vData);
 644
 645         switch(types[i])
 646         {
 647         case DCINFOTYPE_VERSION:
 648             V_VT(&infos[i].vData) = VT_UI4;
 649             V_UI4(&infos[i].vData) = This->version;
 650             break;
 651         }
 652     }
 653
 654     return S_OK;
 655 }
 656
 657 static HRESULT WINAPI dcinfo_SetInfo(IDCInfo* iface, ULONG num, DCINFO info[])
 658 {
 659     convert *This = impl_from_IDCInfo(iface);
 660     ULONG i;
 661     HRESULT hr = S_OK;
 662
 663     TRACE("(%p)->(%d, %p)\n", This, num, info);
 664
 665     for(i = 0; i < num; i++)
 666     {
 667         switch(info[i].eInfoType)
 668         {
 669         case DCINFOTYPE_VERSION:
 670             if(V_VT(&info[i].vData) != VT_UI4)
 671             {
 672                 FIXME("VERSION with vt %x\n", V_VT(&info[i].vData));
 673                 hr = DB_S_ERRORSOCCURRED;
 674                 break;
 675             }
 676             This->version = V_UI4(&info[i].vData);
 677             break;
 678
 679         default:
 680             FIXME("Unhandled info type %d (vt %x)\n", info[i].eInfoType, V_VT(&info[i].vData));
 681         }
 682     }
 683     return hr;
 684 }
 685
 686 static const struct IDCInfoVtbl dcinfo_vtbl =
 687 {
 688     dcinfo_QueryInterface,
 689     dcinfo_AddRef,
 690     dcinfo_Release,
 691     dcinfo_GetInfo,
 692     dcinfo_SetInfo
 693 };
 694
 695 HRESULT create_oledb_convert(IUnknown *outer, void **obj)
 696 {
 697     convert *This;
 698
 699     TRACE("(%p, %p)\n", outer, obj);
 700
 701     *obj = NULL;
 702
 703     if(outer) return CLASS_E_NOAGGREGATION;
 704
 705     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 706     if(!This) return E_OUTOFMEMORY;
 707
 708     This->lpVtbl = &convert_vtbl;
 709     This->lpDCInfoVtbl = &dcinfo_vtbl;
 710     This->ref = 1;
 711     This->version = 0x110;
 712
 713     *obj = &This->lpVtbl;
 714
 715     return S_OK;
 716 }