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_FILETIME:
 132         return sizeof(FILETIME);
 133     case DBTYPE_WSTR:
 134     case DBTYPE_BYREF | DBTYPE_WSTR:
 135         return 0;
 136     default:
 137         FIXME("Unhandled type %04x\n", type);
 138         return 0;
 139     }
 140 }
 141
 142 static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
 143                                           DBTYPE src_type, DBTYPE dst_type,
 144                                           DBLENGTH src_len, DBLENGTH *dst_len,
 145                                           void *src, void *dst,
 146                                           DBLENGTH dst_max_len,
 147                                           DBSTATUS src_status, DBSTATUS *dst_status,
 148                                           BYTE precision, BYTE scale,
 149                                           DBDATACONVERT flags)
 150 {
 151     convert *This = impl_from_IDataConvert(iface);
 152     HRESULT hr;
 153
 154     TRACE("(%p)->(%d, %d, %d, %p, %p, %p, %d, %d, %p, %d, %d, %x)\n", This,
 155           src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
 156           src_status, dst_status, precision, scale, flags);
 157
 158     *dst_len = get_length(dst_type);
 159     *dst_status = DBSTATUS_E_BADACCESSOR;
 160
 161     if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
 162     {
 163         return DB_E_UNSUPPORTEDCONVERSION;
 164     }
 165
 166     if(src_type == DBTYPE_STR)
 167     {
 168         BSTR b;
 169         DWORD len;
 170
 171         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 172             len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
 173         else
 174             len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
 175         b = SysAllocStringLen(NULL, len);
 176         if(!b) return E_OUTOFMEMORY;
 177         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 178             MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
 179         else
 180             MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
 181
 182         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 183                                       &b, dst, dst_max_len, src_status, dst_status,
 184                                       precision, scale, flags);
 185
 186         SysFreeString(b);
 187         return hr;
 188     }
 189
 190     if(src_type == DBTYPE_WSTR)
 191     {
 192         BSTR b;
 193
 194         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 195             b = SysAllocString(src);
 196         else
 197             b = SysAllocStringLen(src, src_len / 2);
 198         if(!b) return E_OUTOFMEMORY;
 199         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 200                                       &b, dst, dst_max_len, src_status, dst_status,
 201                                       precision, scale, flags);
 202         SysFreeString(b);
 203         return hr;
 204     }
 205
 206     switch(dst_type)
 207     {
 208     case DBTYPE_I2:
 209     {
 210         signed short *d = dst;
 211         switch(src_type)
 212         {
 213         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 214         case DBTYPE_I2:          *d = *(signed short*)src; hr = S_OK;            break;
 215         case DBTYPE_I4:          hr = VarI2FromI4(*(signed int*)src, d);         break;
 216         case DBTYPE_R4:          hr = VarI2FromR4(*(FLOAT*)src, d);              break;
 217         case DBTYPE_R8:          hr = VarI2FromR8(*(double*)src, d);             break;
 218         case DBTYPE_CY:          hr = VarI2FromCy(*(CY*)src, d);                 break;
 219         case DBTYPE_DATE:        hr = VarI2FromDate(*(DATE*)src, d);             break;
 220         case DBTYPE_BSTR:        hr = VarI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 221         case DBTYPE_BOOL:        hr = VarI2FromBool(*(VARIANT_BOOL*)src, d);     break;
 222         case DBTYPE_DECIMAL:     hr = VarI2FromDec((DECIMAL*)src, d);            break;
 223         case DBTYPE_I1:          hr = VarI2FromI1(*(signed char*)src, d);        break;
 224         case DBTYPE_UI1:         hr = VarI2FromUI1(*(BYTE*)src, d);              break;
 225         case DBTYPE_UI2:         hr = VarI2FromUI2(*(WORD*)src, d);              break;
 226         case DBTYPE_UI4:         hr = VarI2FromUI4(*(DWORD*)src, d);             break;
 227         case DBTYPE_I8:          hr = VarI2FromI8(*(LONGLONG*)src, d);           break;
 228         case DBTYPE_UI8:         hr = VarI2FromUI8(*(ULONGLONG*)src, d);         break;
 229         default: FIXME("Unimplemented conversion %04x -> I2\n", src_type); return E_NOTIMPL;
 230         }
 231         break;
 232     }
 233
 234     case DBTYPE_I4:
 235     {
 236         signed int *d = dst;
 237         switch(src_type)
 238         {
 239         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 240         case DBTYPE_I2:          hr = VarI4FromI2(*(signed short*)src, d);       break;
 241         case DBTYPE_I4:          *d = *(signed int*)src; hr = S_OK;              break;
 242         case DBTYPE_R4:          hr = VarI4FromR4(*(FLOAT*)src, d);              break;
 243         case DBTYPE_R8:          hr = VarI4FromR8(*(double*)src, d);             break;
 244         case DBTYPE_CY:          hr = VarI4FromCy(*(CY*)src, d);                 break;
 245         case DBTYPE_DATE:        hr = VarI4FromDate(*(DATE*)src, d);             break;
 246         case DBTYPE_BSTR:        hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 247         case DBTYPE_BOOL:        hr = VarI4FromBool(*(VARIANT_BOOL*)src, d);     break;
 248         case DBTYPE_DECIMAL:     hr = VarI4FromDec((DECIMAL*)src, d);            break;
 249         case DBTYPE_I1:          hr = VarI4FromI1(*(signed char*)src, d);        break;
 250         case DBTYPE_UI1:         hr = VarI4FromUI1(*(BYTE*)src, d);              break;
 251         case DBTYPE_UI2:         hr = VarI4FromUI2(*(WORD*)src, d);              break;
 252         case DBTYPE_UI4:         hr = VarI4FromUI4(*(DWORD*)src, d);             break;
 253         case DBTYPE_I8:          hr = VarI4FromI8(*(LONGLONG*)src, d);           break;
 254         case DBTYPE_UI8:         hr = VarI4FromUI8(*(ULONGLONG*)src, d);         break;
 255         default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
 256         }
 257         break;
 258     }
 259
 260     case DBTYPE_BSTR:
 261     {
 262         BSTR *d = dst;
 263         switch(src_type)
 264         {
 265         case DBTYPE_EMPTY:       *d = SysAllocStringLen(NULL, 0); hr = *d ? S_OK : E_OUTOFMEMORY;      break;
 266         case DBTYPE_I2:          hr = VarBstrFromI2(*(signed short*)src, LOCALE_USER_DEFAULT, 0, d);   break;
 267         case DBTYPE_I4:          hr = VarBstrFromI4(*(signed int*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 268         case DBTYPE_R4:          hr = VarBstrFromR4(*(FLOAT*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 269         case DBTYPE_R8:          hr = VarBstrFromR8(*(double*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 270         case DBTYPE_CY:          hr = VarBstrFromCy(*(CY*)src, LOCALE_USER_DEFAULT, 0, d);             break;
 271         case DBTYPE_DATE:        hr = VarBstrFromDate(*(DATE*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 272         case DBTYPE_BSTR:        *d = SysAllocStringLen(*(BSTR*)src, SysStringLen(*(BSTR*)src)); hr = *d ? S_OK : E_OUTOFMEMORY;     break;
 273         case DBTYPE_BOOL:        hr = VarBstrFromBool(*(VARIANT_BOOL*)src, LOCALE_USER_DEFAULT, 0, d); break;
 274         case DBTYPE_DECIMAL:     hr = VarBstrFromDec((DECIMAL*)src, LOCALE_USER_DEFAULT, 0, d);        break;
 275         case DBTYPE_I1:          hr = VarBstrFromI1(*(signed char*)src, LOCALE_USER_DEFAULT, 0, d);    break;
 276         case DBTYPE_UI1:         hr = VarBstrFromUI1(*(BYTE*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 277         case DBTYPE_UI2:         hr = VarBstrFromUI2(*(WORD*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 278         case DBTYPE_UI4:         hr = VarBstrFromUI4(*(DWORD*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 279         case DBTYPE_I8:          hr = VarBstrFromI8(*(LONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);       break;
 280         case DBTYPE_UI8:         hr = VarBstrFromUI8(*(ULONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 281         default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type); return E_NOTIMPL;
 282         }
 283         break;
 284     }
 285
 286     case DBTYPE_FILETIME:
 287     {
 288         FILETIME *d = dst;
 289         switch(src_type)
 290         {
 291         case DBTYPE_EMPTY:       d->dwLowDateTime = d->dwHighDateTime = 0; hr = S_OK;    break;
 292         case DBTYPE_FILETIME:    *d = *(FILETIME*)src; hr = S_OK;                        break;
 293         default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type); return E_NOTIMPL;
 294         }
 295         break;
 296     }
 297
 298     case DBTYPE_WSTR:
 299     {
 300         BSTR b;
 301         DBLENGTH bstr_len;
 302         INT bytes_to_copy;
 303         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 304                                       src, &b, sizeof(BSTR), src_status, dst_status,
 305                                       precision, scale, flags);
 306         if(hr != S_OK) return hr;
 307         bstr_len = SysStringLen(b);
 308         *dst_len = bstr_len * sizeof(WCHAR); /* Doesn't include size for '\0' */
 309         *dst_status = DBSTATUS_S_OK;
 310         bytes_to_copy = min(*dst_len + sizeof(WCHAR), dst_max_len);
 311         if(dst)
 312         {
 313             if(bytes_to_copy >= sizeof(WCHAR))
 314             {
 315                 memcpy(dst, b, bytes_to_copy - sizeof(WCHAR));
 316                 *((WCHAR*)dst + bytes_to_copy / sizeof(WCHAR) - 1) = 0;
 317                 if(bytes_to_copy < *dst_len + sizeof(WCHAR))
 318                     *dst_status = DBSTATUS_S_TRUNCATED;
 319             }
 320             else
 321             {
 322                 *dst_status = DBSTATUS_E_DATAOVERFLOW;
 323                 hr = DB_E_ERRORSOCCURRED;
 324             }
 325         }
 326         SysFreeString(b);
 327         return hr;
 328     }
 329
 330     case DBTYPE_BYREF | DBTYPE_WSTR:
 331     {
 332         BSTR b;
 333         WCHAR **d = dst;
 334         DBLENGTH bstr_len;
 335         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 336                                       src, &b, sizeof(BSTR), src_status, dst_status,
 337                                       precision, scale, flags);
 338         if(hr != S_OK) return hr;
 339
 340         bstr_len = SysStringLen(b) * sizeof(WCHAR);
 341         *dst_len = bstr_len; /* Doesn't include size for '\0' */
 342
 343         *d = CoTaskMemAlloc(bstr_len + sizeof(WCHAR));
 344         if(*d) memcpy(*d, b, bstr_len + sizeof(WCHAR));
 345         else hr = E_OUTOFMEMORY;
 346         SysFreeString(b);
 347         return hr;
 348     }
 349
 350     default:
 351         FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
 352         return E_NOTIMPL;
 353
 354     }
 355
 356     if(hr == DISP_E_OVERFLOW)
 357     {
 358         *dst_status = DBSTATUS_E_DATAOVERFLOW;
 359         hr = DB_E_ERRORSOCCURRED;
 360     }
 361     else if(hr == S_OK)
 362         *dst_status = DBSTATUS_S_OK;
 363
 364     return hr;
 365 }
 366
 367 static inline WORD get_dbtype_class(DBTYPE type)
 368 {
 369     switch(type)
 370     {
 371     case DBTYPE_I2:
 372     case DBTYPE_R4:
 373     case DBTYPE_R8:
 374     case DBTYPE_I1:
 375     case DBTYPE_UI1:
 376     case DBTYPE_UI2:
 377         return DBTYPE_I2;
 378
 379     case DBTYPE_I4:
 380     case DBTYPE_UI4:
 381         return DBTYPE_I4;
 382
 383     case DBTYPE_I8:
 384     case DBTYPE_UI8:
 385         return DBTYPE_I8;
 386
 387     case DBTYPE_BSTR:
 388     case DBTYPE_STR:
 389     case DBTYPE_WSTR:
 390         return DBTYPE_BSTR;
 391
 392     case DBTYPE_DBDATE:
 393     case DBTYPE_DBTIME:
 394     case DBTYPE_DBTIMESTAMP:
 395         return DBTYPE_DBDATE;
 396     }
 397     return type;
 398 }
 399
 400 /* Many src types will convert to this group of dst types */
 401 static inline BOOL common_class(WORD dst_class)
 402 {
 403     switch(dst_class)
 404     {
 405     case DBTYPE_EMPTY:
 406     case DBTYPE_NULL:
 407     case DBTYPE_I2:
 408     case DBTYPE_I4:
 409     case DBTYPE_BSTR:
 410     case DBTYPE_BOOL:
 411     case DBTYPE_VARIANT:
 412     case DBTYPE_I8:
 413     case DBTYPE_CY:
 414     case DBTYPE_DECIMAL:
 415     case DBTYPE_NUMERIC:
 416         return TRUE;
 417     }
 418     return FALSE;
 419 }
 420
 421 static inline BOOL array_type(DBTYPE type)
 422 {
 423     return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
 424 }
 425
 426 static HRESULT WINAPI convert_CanConvert(IDataConvert* iface,
 427                                          DBTYPE src_type, DBTYPE dst_type)
 428 {
 429     convert *This = impl_from_IDataConvert(iface);
 430     DBTYPE src_base_type = src_type & 0x1ff;
 431     DBTYPE dst_base_type = dst_type & 0x1ff;
 432     WORD dst_class = get_dbtype_class(dst_base_type);
 433
 434     TRACE("(%p)->(%d, %d)\n", This, src_type, dst_type);
 435
 436     if(src_type & DBTYPE_VECTOR || dst_type & DBTYPE_VECTOR) return S_FALSE;
 437
 438     if(src_type & DBTYPE_ARRAY)
 439     {
 440         if(!array_type(src_base_type)) return S_FALSE;
 441         if(dst_type & DBTYPE_ARRAY)
 442         {
 443             if(src_type == dst_type) return S_OK;
 444             return S_FALSE;
 445         }
 446         if(dst_type == DBTYPE_VARIANT) return S_OK;
 447         return S_FALSE;
 448     }
 449
 450     if(dst_type & DBTYPE_ARRAY)
 451     {
 452         if(!array_type(dst_base_type)) return S_FALSE;
 453         if(src_type == DBTYPE_IDISPATCH || src_type == DBTYPE_VARIANT) return S_OK;
 454         return S_FALSE;
 455     }
 456
 457     if(dst_type & DBTYPE_BYREF)
 458         if(dst_base_type != DBTYPE_BYTES && dst_base_type != DBTYPE_STR && dst_base_type != DBTYPE_WSTR)
 459             return S_FALSE;
 460
 461     switch(get_dbtype_class(src_base_type))
 462     {
 463     case DBTYPE_EMPTY:
 464         if(common_class(dst_class)) return S_OK;
 465         switch(dst_class)
 466         {
 467         case DBTYPE_DATE:
 468         case DBTYPE_GUID:
 469         case DBTYPE_FILETIME:
 470             return S_OK;
 471         default:
 472             if(dst_base_type == DBTYPE_DBTIMESTAMP) return S_OK;
 473             return S_FALSE;
 474         }
 475
 476     case DBTYPE_NULL:
 477         switch(dst_base_type)
 478         {
 479         case DBTYPE_NULL:
 480         case DBTYPE_VARIANT:
 481         case DBTYPE_FILETIME: return S_OK;
 482         default: return S_FALSE;
 483         }
 484
 485     case DBTYPE_I4:
 486         if(dst_base_type == DBTYPE_BYTES) return S_OK;
 487         /* fall through */
 488     case DBTYPE_I2:
 489         if(dst_base_type == DBTYPE_DATE) return S_OK;
 490         /* fall through */
 491     case DBTYPE_DECIMAL:
 492         if(common_class(dst_class)) return S_OK;
 493         if(dst_class == DBTYPE_DBDATE) return S_OK;
 494         return S_FALSE;
 495
 496     case DBTYPE_BOOL:
 497         if(dst_base_type == DBTYPE_DATE) return S_OK;
 498     case DBTYPE_NUMERIC:
 499     case DBTYPE_CY:
 500         if(common_class(dst_class)) return S_OK;
 501         return S_FALSE;
 502
 503     case DBTYPE_I8:
 504         if(common_class(dst_class)) return S_OK;
 505         switch(dst_base_type)
 506         {
 507         case DBTYPE_BYTES:
 508         case DBTYPE_FILETIME: return S_OK;
 509         default: return S_FALSE;
 510         }
 511
 512     case DBTYPE_DATE:
 513         switch(dst_class)
 514         {
 515         case DBTYPE_EMPTY:
 516         case DBTYPE_NULL:
 517         case DBTYPE_I2:
 518         case DBTYPE_I4:
 519         case DBTYPE_BSTR:
 520         case DBTYPE_BOOL:
 521         case DBTYPE_VARIANT:
 522         case DBTYPE_I8:
 523         case DBTYPE_DATE:
 524         case DBTYPE_DBDATE:
 525         case DBTYPE_FILETIME:
 526             return S_OK;
 527         default: return S_FALSE;
 528         }
 529
 530     case DBTYPE_IDISPATCH:
 531     case DBTYPE_VARIANT:
 532         switch(dst_base_type)
 533         {
 534         case DBTYPE_IDISPATCH:
 535         case DBTYPE_ERROR:
 536         case DBTYPE_IUNKNOWN:
 537             return S_OK;
 538         }
 539         /* fall through */
 540     case DBTYPE_BSTR:
 541         if(common_class(dst_class)) return S_OK;
 542         switch(dst_class)
 543         {
 544         case DBTYPE_DATE:
 545         case DBTYPE_GUID:
 546         case DBTYPE_BYTES:
 547         case DBTYPE_DBDATE:
 548         case DBTYPE_FILETIME:
 549             return S_OK;
 550         default: return S_FALSE;
 551         }
 552
 553     case DBTYPE_ERROR:
 554         switch(dst_base_type)
 555         {
 556         case DBTYPE_BSTR:
 557         case DBTYPE_ERROR:
 558         case DBTYPE_VARIANT:
 559         case DBTYPE_WSTR:
 560             return S_OK;
 561         default: return S_FALSE;
 562         }
 563
 564     case DBTYPE_IUNKNOWN:
 565         switch(dst_base_type)
 566         {
 567         case DBTYPE_EMPTY:
 568         case DBTYPE_NULL:
 569         case DBTYPE_IDISPATCH:
 570         case DBTYPE_VARIANT:
 571         case DBTYPE_IUNKNOWN:
 572             return S_OK;
 573         default: return S_FALSE;
 574         }
 575
 576     case DBTYPE_BYTES:
 577         if(dst_class == DBTYPE_I4 || dst_class == DBTYPE_I8) return S_OK;
 578         /* fall through */
 579     case DBTYPE_GUID:
 580         switch(dst_class)
 581         {
 582         case DBTYPE_EMPTY:
 583         case DBTYPE_NULL:
 584         case DBTYPE_BSTR:
 585         case DBTYPE_VARIANT:
 586         case DBTYPE_GUID:
 587         case DBTYPE_BYTES:
 588             return S_OK;
 589         default: return S_FALSE;
 590         }
 591
 592     case DBTYPE_FILETIME:
 593         if(dst_class == DBTYPE_I8) return S_OK;
 594         /* fall through */
 595     case DBTYPE_DBDATE:
 596         switch(dst_class)
 597         {
 598         case DBTYPE_EMPTY:
 599         case DBTYPE_NULL:
 600         case DBTYPE_DATE:
 601         case DBTYPE_BSTR:
 602         case DBTYPE_VARIANT:
 603         case DBTYPE_DBDATE:
 604         case DBTYPE_FILETIME:
 605             return S_OK;
 606         default: return S_FALSE;
 607         }
 608
 609     }
 610     return S_FALSE;
 611 }
 612
 613 static HRESULT WINAPI convert_GetConversionSize(IDataConvert* iface,
 614                                                 DBTYPE wSrcType, DBTYPE wDstType,
 615                                                 DBLENGTH *pcbSrcLength, DBLENGTH *pcbDstLength,
 616                                                 void *pSrc)
 617 {
 618     convert *This = impl_from_IDataConvert(iface);
 619     FIXME("(%p)->(%d, %d, %p, %p, %p): stub\n", This, wSrcType, wDstType, pcbSrcLength, pcbDstLength, pSrc);
 620
 621     return E_NOTIMPL;
 622 }
 623
 624 static const struct IDataConvertVtbl convert_vtbl =
 625 {
 626     convert_QueryInterface,
 627     convert_AddRef,
 628     convert_Release,
 629     convert_DataConvert,
 630     convert_CanConvert,
 631     convert_GetConversionSize
 632 };
 633
 634 static HRESULT WINAPI dcinfo_QueryInterface(IDCInfo* iface, REFIID riid, void **obj)
 635 {
 636     convert *This = impl_from_IDCInfo(iface);
 637
 638     return IDataConvert_QueryInterface((IDataConvert *)This, riid, obj);
 639 }
 640
 641 static ULONG WINAPI dcinfo_AddRef(IDCInfo* iface)
 642 {
 643     convert *This = impl_from_IDCInfo(iface);
 644
 645     return IDataConvert_AddRef((IDataConvert *)This);
 646 }
 647
 648 static ULONG WINAPI dcinfo_Release(IDCInfo* iface)
 649 {
 650     convert *This = impl_from_IDCInfo(iface);
 651
 652     return IDataConvert_Release((IDataConvert *)This);
 653 }
 654
 655 static HRESULT WINAPI dcinfo_GetInfo(IDCInfo *iface, ULONG num, DCINFOTYPE types[], DCINFO **info_ptr)
 656 {
 657     convert *This = impl_from_IDCInfo(iface);
 658     ULONG i;
 659     DCINFO *infos;
 660
 661     TRACE("(%p)->(%d, %p, %p)\n", This, num, types, info_ptr);
 662
 663     *info_ptr = infos = CoTaskMemAlloc(num * sizeof(*infos));
 664     if(!infos) return E_OUTOFMEMORY;
 665
 666     for(i = 0; i < num; i++)
 667     {
 668         infos[i].eInfoType = types[i];
 669         VariantInit(&infos[i].vData);
 670
 671         switch(types[i])
 672         {
 673         case DCINFOTYPE_VERSION:
 674             V_VT(&infos[i].vData) = VT_UI4;
 675             V_UI4(&infos[i].vData) = This->version;
 676             break;
 677         }
 678     }
 679
 680     return S_OK;
 681 }
 682
 683 static HRESULT WINAPI dcinfo_SetInfo(IDCInfo* iface, ULONG num, DCINFO info[])
 684 {
 685     convert *This = impl_from_IDCInfo(iface);
 686     ULONG i;
 687     HRESULT hr = S_OK;
 688
 689     TRACE("(%p)->(%d, %p)\n", This, num, info);
 690
 691     for(i = 0; i < num; i++)
 692     {
 693         switch(info[i].eInfoType)
 694         {
 695         case DCINFOTYPE_VERSION:
 696             if(V_VT(&info[i].vData) != VT_UI4)
 697             {
 698                 FIXME("VERSION with vt %x\n", V_VT(&info[i].vData));
 699                 hr = DB_S_ERRORSOCCURRED;
 700                 break;
 701             }
 702             This->version = V_UI4(&info[i].vData);
 703             break;
 704
 705         default:
 706             FIXME("Unhandled info type %d (vt %x)\n", info[i].eInfoType, V_VT(&info[i].vData));
 707         }
 708     }
 709     return hr;
 710 }
 711
 712 static const struct IDCInfoVtbl dcinfo_vtbl =
 713 {
 714     dcinfo_QueryInterface,
 715     dcinfo_AddRef,
 716     dcinfo_Release,
 717     dcinfo_GetInfo,
 718     dcinfo_SetInfo
 719 };
 720
 721 HRESULT create_oledb_convert(IUnknown *outer, void **obj)
 722 {
 723     convert *This;
 724
 725     TRACE("(%p, %p)\n", outer, obj);
 726
 727     *obj = NULL;
 728
 729     if(outer) return CLASS_E_NOAGGREGATION;
 730
 731     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 732     if(!This) return E_OUTOFMEMORY;
 733
 734     This->lpVtbl = &convert_vtbl;
 735     This->lpDCInfoVtbl = &dcinfo_vtbl;
 736     This->ref = 1;
 737     This->version = 0x110;
 738
 739     *obj = &This->lpVtbl;
 740
 741     return S_OK;
 742 }