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     IDataConvert IDataConvert_iface;
  42     IDCInfo IDCInfo_iface;
  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 CONTAINING_RECORD(iface, convert, IDataConvert_iface);
  52 }
  53
  54 static inline convert *impl_from_IDCInfo(IDCInfo *iface)
  55 {
  56     return CONTAINING_RECORD(iface, convert, IDCInfo_iface);
  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->IDCInfo_iface;
  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_BOOL:
 124         return sizeof(VARIANT_BOOL);
 125     case DBTYPE_I4:
 126     case DBTYPE_UI4:
 127     case DBTYPE_R4:
 128         return 4;
 129     case DBTYPE_I8:
 130     case DBTYPE_UI8:
 131     case DBTYPE_R8:
 132     case DBTYPE_DATE:
 133         return 8;
 134     case DBTYPE_DBTIMESTAMP:
 135         return sizeof(DBTIMESTAMP);
 136     case DBTYPE_CY:
 137         return sizeof(CY);
 138     case DBTYPE_BSTR:
 139         return sizeof(BSTR);
 140     case DBTYPE_FILETIME:
 141         return sizeof(FILETIME);
 142     case DBTYPE_GUID:
 143         return sizeof(GUID);
 144     case DBTYPE_WSTR:
 145     case DBTYPE_STR:
 146     case DBTYPE_BYREF | DBTYPE_WSTR:
 147         return 0;
 148     default:
 149         FIXME("Unhandled type %04x\n", type);
 150         return 0;
 151     }
 152 }
 153
 154 static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
 155                                           DBTYPE src_type, DBTYPE dst_type,
 156                                           DBLENGTH src_len, DBLENGTH *dst_len,
 157                                           void *src, void *dst,
 158                                           DBLENGTH dst_max_len,
 159                                           DBSTATUS src_status, DBSTATUS *dst_status,
 160                                           BYTE precision, BYTE scale,
 161                                           DBDATACONVERT flags)
 162 {
 163     convert *This = impl_from_IDataConvert(iface);
 164     HRESULT hr;
 165
 166     TRACE("(%p)->(%d, %d, %ld, %p, %p, %p, %ld, %d, %p, %d, %d, %x)\n", This,
 167           src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
 168           src_status, dst_status, precision, scale, flags);
 169
 170     *dst_status = DBSTATUS_E_BADACCESSOR;
 171
 172     if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
 173     {
 174         return DB_E_UNSUPPORTEDCONVERSION;
 175     }
 176
 177     if(src_type == DBTYPE_STR)
 178     {
 179         BSTR b;
 180         DWORD len;
 181
 182         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 183             len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
 184         else
 185             len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
 186         b = SysAllocStringLen(NULL, len);
 187         if(!b) return E_OUTOFMEMORY;
 188         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 189             MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
 190         else
 191             MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
 192
 193         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 194                                       &b, dst, dst_max_len, src_status, dst_status,
 195                                       precision, scale, flags);
 196
 197         SysFreeString(b);
 198         return hr;
 199     }
 200
 201     if(src_type == DBTYPE_WSTR)
 202     {
 203         BSTR b;
 204
 205         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 206             b = SysAllocString(src);
 207         else
 208             b = SysAllocStringLen(src, src_len / 2);
 209         if(!b) return E_OUTOFMEMORY;
 210         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 211                                       &b, dst, dst_max_len, src_status, dst_status,
 212                                       precision, scale, flags);
 213         SysFreeString(b);
 214         return hr;
 215     }
 216
 217     switch(dst_type)
 218     {
 219     case DBTYPE_I2:
 220     {
 221         signed short *d = dst;
 222         VARIANT tmp;
 223         switch(src_type)
 224         {
 225         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 226         case DBTYPE_I2:          *d = *(signed short*)src; hr = S_OK;            break;
 227         case DBTYPE_I4:          hr = VarI2FromI4(*(signed int*)src, d);         break;
 228         case DBTYPE_R4:          hr = VarI2FromR4(*(FLOAT*)src, d);              break;
 229         case DBTYPE_R8:          hr = VarI2FromR8(*(double*)src, d);             break;
 230         case DBTYPE_CY:          hr = VarI2FromCy(*(CY*)src, d);                 break;
 231         case DBTYPE_DATE:        hr = VarI2FromDate(*(DATE*)src, d);             break;
 232         case DBTYPE_BSTR:        hr = VarI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 233         case DBTYPE_BOOL:        hr = VarI2FromBool(*(VARIANT_BOOL*)src, d);     break;
 234         case DBTYPE_DECIMAL:     hr = VarI2FromDec((DECIMAL*)src, d);            break;
 235         case DBTYPE_I1:          hr = VarI2FromI1(*(signed char*)src, d);        break;
 236         case DBTYPE_UI1:         hr = VarI2FromUI1(*(BYTE*)src, d);              break;
 237         case DBTYPE_UI2:         hr = VarI2FromUI2(*(WORD*)src, d);              break;
 238         case DBTYPE_UI4:         hr = VarI2FromUI4(*(DWORD*)src, d);             break;
 239         case DBTYPE_I8:          hr = VarI2FromI8(*(LONGLONG*)src, d);           break;
 240         case DBTYPE_UI8:         hr = VarI2FromUI8(*(ULONGLONG*)src, d);         break;
 241         case DBTYPE_VARIANT:
 242             VariantInit(&tmp);
 243             if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I2)) == S_OK)
 244                 *d = V_I2(&tmp);
 245             break;
 246         default: FIXME("Unimplemented conversion %04x -> I2\n", src_type); return E_NOTIMPL;
 247         }
 248         break;
 249     }
 250
 251     case DBTYPE_I4:
 252     {
 253         signed int *d = dst;
 254         VARIANT tmp;
 255         switch(src_type)
 256         {
 257         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 258         case DBTYPE_I2:          hr = VarI4FromI2(*(signed short*)src, d);       break;
 259         case DBTYPE_I4:          *d = *(signed int*)src; hr = S_OK;              break;
 260         case DBTYPE_R4:          hr = VarI4FromR4(*(FLOAT*)src, d);              break;
 261         case DBTYPE_R8:          hr = VarI4FromR8(*(double*)src, d);             break;
 262         case DBTYPE_CY:          hr = VarI4FromCy(*(CY*)src, d);                 break;
 263         case DBTYPE_DATE:        hr = VarI4FromDate(*(DATE*)src, d);             break;
 264         case DBTYPE_BSTR:        hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 265         case DBTYPE_BOOL:        hr = VarI4FromBool(*(VARIANT_BOOL*)src, d);     break;
 266         case DBTYPE_DECIMAL:     hr = VarI4FromDec((DECIMAL*)src, d);            break;
 267         case DBTYPE_I1:          hr = VarI4FromI1(*(signed char*)src, d);        break;
 268         case DBTYPE_UI1:         hr = VarI4FromUI1(*(BYTE*)src, d);              break;
 269         case DBTYPE_UI2:         hr = VarI4FromUI2(*(WORD*)src, d);              break;
 270         case DBTYPE_UI4:         hr = VarI4FromUI4(*(DWORD*)src, d);             break;
 271         case DBTYPE_I8:          hr = VarI4FromI8(*(LONGLONG*)src, d);           break;
 272         case DBTYPE_UI8:         hr = VarI4FromUI8(*(ULONGLONG*)src, d);         break;
 273         case DBTYPE_VARIANT:
 274             VariantInit(&tmp);
 275             if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I4)) == S_OK)
 276                 *d = V_I4(&tmp);
 277             break;
 278         default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
 279         }
 280         break;
 281     }
 282
 283     case DBTYPE_R4:
 284     {
 285         FLOAT *d = dst;
 286         switch(src_type)
 287         {
 288         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 289         case DBTYPE_I2:          hr = VarR4FromI2(*(signed short*)src, d);       break;
 290         case DBTYPE_I4:          hr = VarR4FromI4(*(signed int*)src, d);         break;
 291         case DBTYPE_R4:          *d = *(FLOAT*)src; hr = S_OK;                   break;
 292         case DBTYPE_R8:          hr = VarR4FromR8(*(double*)src, d);             break;
 293         case DBTYPE_CY:          hr = VarR4FromCy(*(CY*)src, d);                 break;
 294         case DBTYPE_DATE:        hr = VarR4FromDate(*(DATE*)src, d);             break;
 295         case DBTYPE_BSTR:        hr = VarR4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 296         case DBTYPE_BOOL:        hr = VarR4FromBool(*(VARIANT_BOOL*)src, d);     break;
 297         case DBTYPE_DECIMAL:     hr = VarR4FromDec((DECIMAL*)src, d);            break;
 298         case DBTYPE_I1:          hr = VarR4FromI1(*(signed char*)src, d);        break;
 299         case DBTYPE_UI1:         hr = VarR4FromUI1(*(BYTE*)src, d);              break;
 300         case DBTYPE_UI2:         hr = VarR4FromUI2(*(WORD*)src, d);              break;
 301         case DBTYPE_UI4:         hr = VarR4FromUI4(*(DWORD*)src, d);             break;
 302         case DBTYPE_I8:          hr = VarR4FromI8(*(LONGLONG*)src, d);           break;
 303         case DBTYPE_UI8:         hr = VarR4FromUI8(*(ULONGLONG*)src, d);         break;
 304         default: FIXME("Unimplemented conversion %04x -> R4\n", src_type); return E_NOTIMPL;
 305         }
 306         break;
 307     }
 308     case DBTYPE_R8:
 309     {
 310         DOUBLE *d=dst;
 311         switch (src_type)
 312         {
 313         case DBTYPE_EMPTY:      *d = 0; hr = S_OK;                               break;
 314         case DBTYPE_I1:          hr = VarR8FromI1(*(signed char*)src, d);        break;
 315         case DBTYPE_I2:          hr = VarR8FromI2(*(signed short*)src, d);       break;
 316         case DBTYPE_I4:          hr = VarR8FromI4(*(signed int*)src, d);         break;
 317         case DBTYPE_I8:          hr = VarR8FromI8(*(LONGLONG*)src, d);           break;
 318         case DBTYPE_UI1:         hr = VarR8FromUI1(*(BYTE*)src, d);              break;
 319         case DBTYPE_UI2:         hr = VarR8FromUI2(*(WORD*)src, d);              break;
 320         case DBTYPE_UI4:         hr = VarR8FromUI4(*(DWORD*)src, d);             break;
 321         case DBTYPE_UI8:         hr = VarR8FromUI8(*(ULONGLONG*)src, d);         break;
 322         case DBTYPE_R4:          hr = VarR8FromR4(*(FLOAT*)src, d);              break;
 323         case DBTYPE_R8:          *d = *(DOUBLE*)src; hr = S_OK;                  break;
 324         case DBTYPE_CY:          hr = VarR8FromCy(*(CY*)src, d);                 break;
 325         case DBTYPE_DATE:        hr = VarR8FromDate(*(DATE*)src, d);             break;
 326         case DBTYPE_BSTR:        hr = VarR8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 327         case DBTYPE_BOOL:        hr = VarR8FromBool(*(VARIANT_BOOL*)src, d);     break;
 328         case DBTYPE_DECIMAL:     hr = VarR8FromDec((DECIMAL*)src, d);            break;
 329         default: FIXME("Unimplemented conversion %04x -> R8\n", src_type); return E_NOTIMPL;
 330         }
 331         break;
 332     }
 333     case DBTYPE_BOOL:
 334     {
 335         VARIANT_BOOL *d=dst;
 336         switch (src_type)
 337         {
 338         case DBTYPE_EMPTY:      *d = 0; hr = S_OK;                               break;
 339         case DBTYPE_I1:          hr = VarBoolFromI1(*(signed char*)src, d);      break;
 340         case DBTYPE_I2:          hr = VarBoolFromI2(*(signed short*)src, d);     break;
 341         case DBTYPE_I4:          hr = VarBoolFromI4(*(signed int*)src, d);       break;
 342         case DBTYPE_I8:          hr = VarBoolFromI8(*(LONGLONG*)src, d);         break;
 343         case DBTYPE_UI1:         hr = VarBoolFromUI1(*(BYTE*)src, d);            break;
 344         case DBTYPE_UI2:         hr = VarBoolFromUI2(*(WORD*)src, d);            break;
 345         case DBTYPE_UI4:         hr = VarBoolFromUI4(*(DWORD*)src, d);           break;
 346         case DBTYPE_UI8:         hr = VarBoolFromUI8(*(ULONGLONG*)src, d);       break;
 347         case DBTYPE_R4:          hr = VarBoolFromR4(*(FLOAT*)src, d);            break;
 348         case DBTYPE_R8:          hr = VarBoolFromR8(*(DOUBLE*)src, d);           break;
 349         case DBTYPE_CY:          hr = VarBoolFromCy(*(CY*)src, d);               break;
 350         case DBTYPE_DATE:        hr = VarBoolFromDate(*(DATE*)src, d);           break;
 351         case DBTYPE_BSTR:        hr = VarBoolFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 352         case DBTYPE_BOOL:        *d = *(VARIANT_BOOL*)src; hr = S_OK;            break;
 353         case DBTYPE_DECIMAL:     hr = VarBoolFromDec((DECIMAL*)src, d);          break;
 354         default: FIXME("Unimplemented conversion %04x -> BOOL\n", src_type); return E_NOTIMPL;
 355         }
 356         break;
 357     }
 358     case DBTYPE_DATE:
 359     {
 360         DATE *d=dst;
 361         switch (src_type)
 362         {
 363         case DBTYPE_EMPTY:      *d = 0; hr = S_OK;                               break;
 364         case DBTYPE_I1:          hr = VarDateFromI1(*(signed char*)src, d);      break;
 365         case DBTYPE_I2:          hr = VarDateFromI2(*(signed short*)src, d);     break;
 366         case DBTYPE_I4:          hr = VarDateFromI4(*(signed int*)src, d);       break;
 367         case DBTYPE_I8:          hr = VarDateFromI8(*(LONGLONG*)src, d);         break;
 368         case DBTYPE_UI1:         hr = VarDateFromUI1(*(BYTE*)src, d);            break;
 369         case DBTYPE_UI2:         hr = VarDateFromUI2(*(WORD*)src, d);            break;
 370         case DBTYPE_UI4:         hr = VarDateFromUI4(*(DWORD*)src, d);           break;
 371         case DBTYPE_UI8:         hr = VarDateFromUI8(*(ULONGLONG*)src, d);       break;
 372         case DBTYPE_R4:          hr = VarDateFromR4(*(FLOAT*)src, d);            break;
 373         case DBTYPE_R8:          hr = VarDateFromR8(*(DOUBLE*)src, d);           break;
 374         case DBTYPE_CY:          hr = VarDateFromCy(*(CY*)src, d);               break;
 375         case DBTYPE_DATE:       *d = *(DATE*)src;      hr = S_OK;                break;
 376         case DBTYPE_BSTR:        hr = VarDateFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 377         case DBTYPE_BOOL:        hr = VarDateFromBool(*(VARIANT_BOOL*)src, d);   break;
 378         case DBTYPE_DECIMAL:     hr = VarDateFromDec((DECIMAL*)src, d);          break;
 379         case DBTYPE_DBTIMESTAMP:
 380         {
 381             SYSTEMTIME st;
 382             DBTIMESTAMP *ts=(DBTIMESTAMP*)src;
 383
 384             st.wYear = ts->year;
 385             st.wMonth = ts->month;
 386             st.wDay = ts->day;
 387             st.wHour = ts->hour;
 388             st.wMinute = ts->minute;
 389             st.wSecond = ts->second;
 390             st.wMilliseconds = ts->fraction/1000000;
 391             hr = (SystemTimeToVariantTime(&st, d) ? S_OK : E_FAIL);
 392             break;
 393         }
 394         default: FIXME("Unimplemented conversion %04x -> DATE\n", src_type); return E_NOTIMPL;
 395         }
 396         break;
 397     }
 398     case DBTYPE_DBTIMESTAMP:
 399     {
 400         DBTIMESTAMP *d=dst;
 401         switch (src_type)
 402         {
 403         case DBTYPE_EMPTY:       memset(d, 0, sizeof(DBTIMESTAMP));    hr = S_OK; break;
 404         case DBTYPE_DBTIMESTAMP: memcpy(d, src, sizeof(DBTIMESTAMP));  hr = S_OK; break;
 405         case DBTYPE_DATE:
 406         {
 407             SYSTEMTIME st;
 408             hr = (VariantTimeToSystemTime(*(double*)src, &st) ? S_OK : E_FAIL);
 409             d->year = st.wYear;
 410             d->month = st.wMonth;
 411             d->day = st.wDay;
 412             d->hour = st.wHour;
 413             d->minute = st.wMinute;
 414             d->second = st.wSecond;
 415             d->fraction = st.wMilliseconds * 1000000;
 416             break;
 417         }
 418         default: FIXME("Unimplemented conversion %04x -> DBTIMESTAMP\n", src_type); return E_NOTIMPL;
 419         }
 420         break;
 421     }
 422
 423     case DBTYPE_CY:
 424     {
 425         CY *d = dst;
 426         switch(src_type)
 427         {
 428         case DBTYPE_EMPTY:       d->int64 = 0; hr = S_OK;                              break;
 429         case DBTYPE_I2:          hr = VarCyFromI2(*(signed short*)src, d);       break;
 430         case DBTYPE_I4:          hr = VarCyFromI4(*(signed int*)src, d);         break;
 431         case DBTYPE_R4:          hr = VarCyFromR4(*(FLOAT*)src, d);              break;
 432         case DBTYPE_R8:          hr = VarCyFromR8(*(double*)src, d);             break;
 433         case DBTYPE_CY:          *d = *(CY*)src; hr = S_OK;                      break;
 434         case DBTYPE_DATE:        hr = VarCyFromDate(*(DATE*)src, d);             break;
 435         case DBTYPE_BSTR:        hr = VarCyFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 436         case DBTYPE_BOOL:        hr = VarCyFromBool(*(VARIANT_BOOL*)src, d);     break;
 437         case DBTYPE_DECIMAL:     hr = VarCyFromDec((DECIMAL*)src, d);            break;
 438         case DBTYPE_I1:          hr = VarCyFromI1(*(signed char*)src, d);        break;
 439         case DBTYPE_UI1:         hr = VarCyFromUI1(*(BYTE*)src, d);              break;
 440         case DBTYPE_UI2:         hr = VarCyFromUI2(*(WORD*)src, d);              break;
 441         case DBTYPE_UI4:         hr = VarCyFromUI4(*(DWORD*)src, d);             break;
 442         case DBTYPE_I8:          hr = VarCyFromI8(*(LONGLONG*)src, d);           break;
 443         case DBTYPE_UI8:         hr = VarCyFromUI8(*(ULONGLONG*)src, d);         break;
 444         default: FIXME("Unimplemented conversion %04x -> CY\n", src_type); return E_NOTIMPL;
 445         }
 446         break;
 447     }
 448
 449     case DBTYPE_BSTR:
 450     {
 451         BSTR *d = dst;
 452         switch(src_type)
 453         {
 454         case DBTYPE_EMPTY:       *d = SysAllocStringLen(NULL, 0); hr = *d ? S_OK : E_OUTOFMEMORY;      break;
 455         case DBTYPE_I2:          hr = VarBstrFromI2(*(signed short*)src, LOCALE_USER_DEFAULT, 0, d);   break;
 456         case DBTYPE_I4:          hr = VarBstrFromI4(*(signed int*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 457         case DBTYPE_R4:          hr = VarBstrFromR4(*(FLOAT*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 458         case DBTYPE_R8:          hr = VarBstrFromR8(*(double*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 459         case DBTYPE_CY:          hr = VarBstrFromCy(*(CY*)src, LOCALE_USER_DEFAULT, 0, d);             break;
 460         case DBTYPE_DATE:        hr = VarBstrFromDate(*(DATE*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 461         case DBTYPE_BSTR:        *d = SysAllocStringLen(*(BSTR*)src, SysStringLen(*(BSTR*)src)); hr = *d ? S_OK : E_OUTOFMEMORY;     break;
 462         case DBTYPE_BOOL:        hr = VarBstrFromBool(*(VARIANT_BOOL*)src, LOCALE_USER_DEFAULT, 0, d); break;
 463         case DBTYPE_DECIMAL:     hr = VarBstrFromDec((DECIMAL*)src, LOCALE_USER_DEFAULT, 0, d);        break;
 464         case DBTYPE_I1:          hr = VarBstrFromI1(*(signed char*)src, LOCALE_USER_DEFAULT, 0, d);    break;
 465         case DBTYPE_UI1:         hr = VarBstrFromUI1(*(BYTE*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 466         case DBTYPE_UI2:         hr = VarBstrFromUI2(*(WORD*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 467         case DBTYPE_UI4:         hr = VarBstrFromUI4(*(DWORD*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 468         case DBTYPE_I8:          hr = VarBstrFromI8(*(LONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);       break;
 469         case DBTYPE_UI8:         hr = VarBstrFromUI8(*(ULONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 470         case DBTYPE_GUID:
 471         {
 472             WCHAR szBuff[39];
 473             const GUID *id = (const GUID *)src;
 474             WCHAR format[] = {
 475                 '{','%','0','8','X','-','%','0','4','X','-','%','0','4','X','-',
 476                 '%','0','2','X','%','0','2','X','-',
 477                 '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','}',0};
 478             wsprintfW(szBuff, format,
 479                 id->Data1, id->Data2, id->Data3,
 480                 id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
 481                 id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
 482             *d = SysAllocString(szBuff);
 483             hr = *d ? S_OK : E_OUTOFMEMORY;
 484         }
 485         break;
 486         case DBTYPE_BYTES:
 487         {
 488             *d = SysAllocStringLen(NULL, 2 * src_len);
 489             if (*d == NULL)
 490                 hr = E_OUTOFMEMORY;
 491             else
 492             {
 493                 const char hexchars[] = "0123456789ABCDEF";
 494                 WCHAR *s = *d;
 495                 unsigned char *p = src;
 496                 while (src_len > 0)
 497                 {
 498                     *s++ = hexchars[(*p >> 4) & 0x0F];
 499                     *s++ = hexchars[(*p)      & 0x0F];
 500                     src_len--; p++;
 501                 }
 502                 hr = S_OK;
 503             }
 504         }
 505         break;
 506         case DBTYPE_VARIANT:
 507         {
 508             VARIANT tmp;
 509
 510             VariantInit(&tmp);
 511             if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_BSTR)) == S_OK)
 512                 *d = V_BSTR(&tmp);
 513         }
 514         break;
 515         default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type); return E_NOTIMPL;
 516         }
 517         break;
 518     }
 519
 520     case DBTYPE_UI1:
 521     {
 522         BYTE *d = dst;
 523         switch(src_type)
 524         {
 525         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 526         case DBTYPE_I2:          hr = VarUI1FromI2(*(signed short*)src, d);      break;
 527         case DBTYPE_I4:          hr = VarUI1FromI4(*(signed int*)src, d);        break;
 528         case DBTYPE_R4:          hr = VarUI1FromR4(*(FLOAT*)src, d);             break;
 529         case DBTYPE_R8:          hr = VarUI1FromR8(*(double*)src, d);            break;
 530         case DBTYPE_CY:          hr = VarUI1FromCy(*(CY*)src, d);                break;
 531         case DBTYPE_DATE:        hr = VarUI1FromDate(*(DATE*)src, d);            break;
 532         case DBTYPE_BSTR:        hr = VarUI1FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 533         case DBTYPE_BOOL:        hr = VarUI1FromBool(*(VARIANT_BOOL*)src, d);    break;
 534         case DBTYPE_DECIMAL:     hr = VarUI1FromDec((DECIMAL*)src, d);           break;
 535         case DBTYPE_I1:          hr = VarUI1FromI1(*(signed char*)src, d);       break;
 536         case DBTYPE_UI1:         *d = *(BYTE*)src; hr = S_OK;                    break;
 537         case DBTYPE_UI2:         hr = VarUI1FromUI2(*(WORD*)src, d);             break;
 538         case DBTYPE_UI4:         hr = VarUI1FromUI4(*(DWORD*)src, d);            break;
 539         case DBTYPE_I8:          hr = VarUI1FromI8(*(LONGLONG*)src, d);          break;
 540         case DBTYPE_UI8:         hr = VarUI1FromUI8(*(ULONGLONG*)src, d);        break;
 541         default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type); return E_NOTIMPL;
 542         }
 543         break;
 544     }
 545     case DBTYPE_UI2:
 546     {
 547         WORD *d = dst;
 548         switch(src_type)
 549         {
 550         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 551         case DBTYPE_I2:          hr = VarUI2FromI2(*(signed short*)src, d);      break;
 552         case DBTYPE_I4:          hr = VarUI2FromI4(*(signed int*)src, d);        break;
 553         case DBTYPE_R4:          hr = VarUI2FromR4(*(FLOAT*)src, d);             break;
 554         case DBTYPE_R8:          hr = VarUI2FromR8(*(double*)src, d);            break;
 555         case DBTYPE_CY:          hr = VarUI2FromCy(*(CY*)src, d);                break;
 556         case DBTYPE_DATE:        hr = VarUI2FromDate(*(DATE*)src, d);            break;
 557         case DBTYPE_BSTR:        hr = VarUI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 558         case DBTYPE_BOOL:        hr = VarUI2FromBool(*(VARIANT_BOOL*)src, d);    break;
 559         case DBTYPE_DECIMAL:     hr = VarUI2FromDec((DECIMAL*)src, d);           break;
 560         case DBTYPE_I1:          hr = VarUI2FromI1(*(signed char*)src, d);       break;
 561         case DBTYPE_UI1:         hr = VarUI2FromUI1(*(BYTE*)src, d);             break;
 562         case DBTYPE_UI2:         *d = *(WORD*)src; hr = S_OK;                     break;
 563         case DBTYPE_UI4:         hr = VarUI2FromUI4(*(DWORD*)src, d);            break;
 564         case DBTYPE_I8:          hr = VarUI2FromI8(*(LONGLONG*)src, d);          break;
 565         case DBTYPE_UI8:         hr = VarUI2FromUI8(*(ULONGLONG*)src, d);        break;
 566         default: FIXME("Unimplemented conversion %04x -> UI2\n", src_type); return E_NOTIMPL;
 567         }
 568         break;
 569     }
 570
 571     case DBTYPE_UI4:
 572     {
 573         DWORD *d = dst;
 574         switch(src_type)
 575         {
 576         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 577         case DBTYPE_I2:          hr = VarUI4FromI2(*(signed short*)src, d);      break;
 578         case DBTYPE_I4:          hr = VarUI4FromI4(*(signed int*)src, d);        break;
 579         case DBTYPE_R4:          hr = VarUI4FromR4(*(FLOAT*)src, d);             break;
 580         case DBTYPE_R8:          hr = VarUI4FromR8(*(double*)src, d);            break;
 581         case DBTYPE_CY:          hr = VarUI4FromCy(*(CY*)src, d);                break;
 582         case DBTYPE_DATE:        hr = VarUI4FromDate(*(DATE*)src, d);            break;
 583         case DBTYPE_BSTR:        hr = VarUI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 584         case DBTYPE_BOOL:        hr = VarUI4FromBool(*(VARIANT_BOOL*)src, d);    break;
 585         case DBTYPE_DECIMAL:     hr = VarUI4FromDec((DECIMAL*)src, d);           break;
 586         case DBTYPE_I1:          hr = VarUI4FromI1(*(signed char*)src, d);       break;
 587         case DBTYPE_UI1:         hr = VarUI4FromUI1(*(BYTE*)src, d);             break;
 588         case DBTYPE_UI2:         hr = VarUI4FromUI2(*(WORD*)src, d);             break;
 589         case DBTYPE_UI4:         *d = *(DWORD*)src; hr = S_OK;                   break;
 590         case DBTYPE_I8:          hr = VarUI4FromI8(*(LONGLONG*)src, d);          break;
 591         case DBTYPE_UI8:         hr = VarUI4FromUI8(*(ULONGLONG*)src, d);        break;
 592         default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type); return E_NOTIMPL;
 593         }
 594         break;
 595     }
 596
 597     case DBTYPE_UI8:
 598     {
 599         ULONGLONG *d = dst;
 600         switch(src_type)
 601         {
 602         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 603         case DBTYPE_I2:          hr = VarUI8FromI2(*(signed short*)src, d);      break;
 604         case DBTYPE_I4:          {LONGLONG s = *(signed int*)src; hr = VarUI8FromI8(s, d);        break;}
 605         case DBTYPE_R4:          hr = VarUI8FromR4(*(FLOAT*)src, d);             break;
 606         case DBTYPE_R8:          hr = VarUI8FromR8(*(double*)src, d);            break;
 607         case DBTYPE_CY:          hr = VarUI8FromCy(*(CY*)src, d);                break;
 608         case DBTYPE_DATE:        hr = VarUI8FromDate(*(DATE*)src, d);            break;
 609         case DBTYPE_BSTR:        hr = VarUI8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 610         case DBTYPE_BOOL:        hr = VarUI8FromBool(*(VARIANT_BOOL*)src, d);    break;
 611         case DBTYPE_DECIMAL:     hr = VarUI8FromDec((DECIMAL*)src, d);           break;
 612         case DBTYPE_I1:          hr = VarUI8FromI1(*(signed char*)src, d);       break;
 613         case DBTYPE_UI1:         hr = VarUI8FromUI1(*(BYTE*)src, d);             break;
 614         case DBTYPE_UI2:         hr = VarUI8FromUI2(*(WORD*)src, d);             break;
 615         case DBTYPE_UI4:         hr = VarUI8FromUI4(*(DWORD*)src, d);            break;
 616         case DBTYPE_I8:          hr = VarUI8FromI8(*(LONGLONG*)src, d);          break;
 617         case DBTYPE_UI8:         *d = *(ULONGLONG*)src; hr = S_OK;               break;
 618         default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type); return E_NOTIMPL;
 619         }
 620         break;
 621     }
 622
 623     case DBTYPE_FILETIME:
 624     {
 625         FILETIME *d = dst;
 626         switch(src_type)
 627         {
 628         case DBTYPE_EMPTY:       d->dwLowDateTime = d->dwHighDateTime = 0; hr = S_OK;    break;
 629         case DBTYPE_FILETIME:    *d = *(FILETIME*)src; hr = S_OK;                        break;
 630         default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type); return E_NOTIMPL;
 631         }
 632         break;
 633     }
 634
 635     case DBTYPE_GUID:
 636     {
 637         GUID *d = dst;
 638         switch(src_type)
 639         {
 640         case DBTYPE_EMPTY:       *d = GUID_NULL; hr = S_OK; break;
 641         case DBTYPE_GUID:        *d = *(GUID*)src; hr = S_OK; break;
 642         default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type); return E_NOTIMPL;
 643         }
 644         break;
 645     }
 646
 647     case DBTYPE_WSTR:
 648     {
 649         BSTR b;
 650         DBLENGTH bstr_len;
 651         INT bytes_to_copy;
 652         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 653                                       src, &b, sizeof(BSTR), src_status, dst_status,
 654                                       precision, scale, flags);
 655         if(hr != S_OK) return hr;
 656         bstr_len = SysStringLen(b);
 657         *dst_len = bstr_len * sizeof(WCHAR); /* Doesn't include size for '\0' */
 658         *dst_status = DBSTATUS_S_OK;
 659         bytes_to_copy = min(*dst_len + sizeof(WCHAR), dst_max_len);
 660         if(dst)
 661         {
 662             if(bytes_to_copy >= sizeof(WCHAR))
 663             {
 664                 memcpy(dst, b, bytes_to_copy - sizeof(WCHAR));
 665                 *((WCHAR*)dst + bytes_to_copy / sizeof(WCHAR) - 1) = 0;
 666                 if(bytes_to_copy < *dst_len + sizeof(WCHAR))
 667                     *dst_status = DBSTATUS_S_TRUNCATED;
 668             }
 669             else
 670             {
 671                 *dst_status = DBSTATUS_E_DATAOVERFLOW;
 672                 hr = DB_E_ERRORSOCCURRED;
 673             }
 674         }
 675         SysFreeString(b);
 676         return hr;
 677     }
 678     case DBTYPE_STR:
 679     {
 680         BSTR b;
 681         DBLENGTH bstr_len;
 682         INT bytes_to_copy;
 683         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 684                                       src, &b, sizeof(BSTR), src_status, dst_status,
 685                                       precision, scale, flags);
 686         if(hr != S_OK) return hr;
 687         bstr_len = SysStringLen(b);
 688         *dst_len = bstr_len * sizeof(char); /* Doesn't include size for '\0' */
 689         *dst_status = DBSTATUS_S_OK;
 690         bytes_to_copy = min(*dst_len + sizeof(char), dst_max_len);
 691         if(dst)
 692         {
 693             if(bytes_to_copy >= sizeof(char))
 694             {
 695                 WideCharToMultiByte(CP_ACP, 0, b, bytes_to_copy - sizeof(char), dst, dst_max_len, NULL, NULL);
 696                 *((char *)dst + bytes_to_copy / sizeof(char) - 1) = 0;
 697                 if(bytes_to_copy < *dst_len + sizeof(char))
 698                     *dst_status = DBSTATUS_S_TRUNCATED;
 699             }
 700             else
 701             {
 702                 *dst_status = DBSTATUS_E_DATAOVERFLOW;
 703                 hr = DB_E_ERRORSOCCURRED;
 704             }
 705         }
 706         SysFreeString(b);
 707         return hr;
 708     }
 709
 710     case DBTYPE_BYREF | DBTYPE_WSTR:
 711     {
 712         BSTR b;
 713         WCHAR **d = dst;
 714         DBLENGTH bstr_len;
 715         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 716                                       src, &b, sizeof(BSTR), src_status, dst_status,
 717                                       precision, scale, flags);
 718         if(hr != S_OK) return hr;
 719
 720         bstr_len = SysStringLen(b) * sizeof(WCHAR);
 721         *dst_len = bstr_len; /* Doesn't include size for '\0' */
 722
 723         *d = CoTaskMemAlloc(bstr_len + sizeof(WCHAR));
 724         if(*d) memcpy(*d, b, bstr_len + sizeof(WCHAR));
 725         else hr = E_OUTOFMEMORY;
 726         SysFreeString(b);
 727         return hr;
 728     }
 729
 730     default:
 731         FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
 732         return E_NOTIMPL;
 733
 734     }
 735
 736     if(hr == DISP_E_OVERFLOW)
 737     {
 738         *dst_status = DBSTATUS_E_DATAOVERFLOW;
 739         *dst_len = get_length(dst_type);
 740         hr = DB_E_ERRORSOCCURRED;
 741     }
 742     else if(hr == S_OK)
 743     {
 744         *dst_status = DBSTATUS_S_OK;
 745         *dst_len = get_length(dst_type);
 746     }
 747
 748     return hr;
 749 }
 750
 751 static inline WORD get_dbtype_class(DBTYPE type)
 752 {
 753     switch(type)
 754     {
 755     case DBTYPE_I2:
 756     case DBTYPE_R4:
 757     case DBTYPE_R8:
 758     case DBTYPE_I1:
 759     case DBTYPE_UI1:
 760     case DBTYPE_UI2:
 761         return DBTYPE_I2;
 762
 763     case DBTYPE_I4:
 764     case DBTYPE_UI4:
 765         return DBTYPE_I4;
 766
 767     case DBTYPE_I8:
 768     case DBTYPE_UI8:
 769         return DBTYPE_I8;
 770
 771     case DBTYPE_BSTR:
 772     case DBTYPE_STR:
 773     case DBTYPE_WSTR:
 774         return DBTYPE_BSTR;
 775
 776     case DBTYPE_DBDATE:
 777     case DBTYPE_DBTIME:
 778     case DBTYPE_DBTIMESTAMP:
 779         return DBTYPE_DBDATE;
 780     }
 781     return type;
 782 }
 783
 784 /* Many src types will convert to this group of dst types */
 785 static inline BOOL common_class(WORD dst_class)
 786 {
 787     switch(dst_class)
 788     {
 789     case DBTYPE_EMPTY:
 790     case DBTYPE_NULL:
 791     case DBTYPE_I2:
 792     case DBTYPE_I4:
 793     case DBTYPE_BSTR:
 794     case DBTYPE_BOOL:
 795     case DBTYPE_VARIANT:
 796     case DBTYPE_I8:
 797     case DBTYPE_CY:
 798     case DBTYPE_DECIMAL:
 799     case DBTYPE_NUMERIC:
 800         return TRUE;
 801     }
 802     return FALSE;
 803 }
 804
 805 static inline BOOL array_type(DBTYPE type)
 806 {
 807     return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
 808 }
 809
 810 static HRESULT WINAPI convert_CanConvert(IDataConvert* iface,
 811                                          DBTYPE src_type, DBTYPE dst_type)
 812 {
 813     convert *This = impl_from_IDataConvert(iface);
 814     DBTYPE src_base_type = src_type & 0x1ff;
 815     DBTYPE dst_base_type = dst_type & 0x1ff;
 816     WORD dst_class = get_dbtype_class(dst_base_type);
 817
 818     TRACE("(%p)->(%d, %d)\n", This, src_type, dst_type);
 819
 820     if(src_type & DBTYPE_VECTOR || dst_type & DBTYPE_VECTOR) return S_FALSE;
 821
 822     if(src_type & DBTYPE_ARRAY)
 823     {
 824         if(!array_type(src_base_type)) return S_FALSE;
 825         if(dst_type & DBTYPE_ARRAY)
 826         {
 827             if(src_type == dst_type) return S_OK;
 828             return S_FALSE;
 829         }
 830         if(dst_type == DBTYPE_VARIANT) return S_OK;
 831         return S_FALSE;
 832     }
 833
 834     if(dst_type & DBTYPE_ARRAY)
 835     {
 836         if(!array_type(dst_base_type)) return S_FALSE;
 837         if(src_type == DBTYPE_IDISPATCH || src_type == DBTYPE_VARIANT) return S_OK;
 838         return S_FALSE;
 839     }
 840
 841     if(dst_type & DBTYPE_BYREF)
 842         if(dst_base_type != DBTYPE_BYTES && dst_base_type != DBTYPE_STR && dst_base_type != DBTYPE_WSTR)
 843             return S_FALSE;
 844
 845     switch(get_dbtype_class(src_base_type))
 846     {
 847     case DBTYPE_EMPTY:
 848         if(common_class(dst_class)) return S_OK;
 849         switch(dst_class)
 850         {
 851         case DBTYPE_DATE:
 852         case DBTYPE_GUID:
 853         case DBTYPE_FILETIME:
 854             return S_OK;
 855         default:
 856             if(dst_base_type == DBTYPE_DBTIMESTAMP) return S_OK;
 857             return S_FALSE;
 858         }
 859
 860     case DBTYPE_NULL:
 861         switch(dst_base_type)
 862         {
 863         case DBTYPE_NULL:
 864         case DBTYPE_VARIANT:
 865         case DBTYPE_FILETIME: return S_OK;
 866         default: return S_FALSE;
 867         }
 868
 869     case DBTYPE_I4:
 870         if(dst_base_type == DBTYPE_BYTES) return S_OK;
 871         /* fall through */
 872     case DBTYPE_I2:
 873         if(dst_base_type == DBTYPE_DATE) return S_OK;
 874         /* fall through */
 875     case DBTYPE_DECIMAL:
 876         if(common_class(dst_class)) return S_OK;
 877         if(dst_class == DBTYPE_DBDATE) return S_OK;
 878         return S_FALSE;
 879
 880     case DBTYPE_BOOL:
 881         if(dst_base_type == DBTYPE_DATE) return S_OK;
 882         /* fall through */
 883     case DBTYPE_NUMERIC:
 884     case DBTYPE_CY:
 885         if(common_class(dst_class)) return S_OK;
 886         return S_FALSE;
 887
 888     case DBTYPE_I8:
 889         if(common_class(dst_class)) return S_OK;
 890         switch(dst_base_type)
 891         {
 892         case DBTYPE_BYTES:
 893         case DBTYPE_FILETIME: return S_OK;
 894         default: return S_FALSE;
 895         }
 896
 897     case DBTYPE_DATE:
 898         switch(dst_class)
 899         {
 900         case DBTYPE_EMPTY:
 901         case DBTYPE_NULL:
 902         case DBTYPE_I2:
 903         case DBTYPE_I4:
 904         case DBTYPE_BSTR:
 905         case DBTYPE_BOOL:
 906         case DBTYPE_VARIANT:
 907         case DBTYPE_I8:
 908         case DBTYPE_DATE:
 909         case DBTYPE_DBDATE:
 910         case DBTYPE_FILETIME:
 911             return S_OK;
 912         default: return S_FALSE;
 913         }
 914
 915     case DBTYPE_IDISPATCH:
 916     case DBTYPE_VARIANT:
 917         switch(dst_base_type)
 918         {
 919         case DBTYPE_IDISPATCH:
 920         case DBTYPE_ERROR:
 921         case DBTYPE_IUNKNOWN:
 922             return S_OK;
 923         }
 924         /* fall through */
 925     case DBTYPE_BSTR:
 926         if(common_class(dst_class)) return S_OK;
 927         switch(dst_class)
 928         {
 929         case DBTYPE_DATE:
 930         case DBTYPE_GUID:
 931         case DBTYPE_BYTES:
 932         case DBTYPE_DBDATE:
 933         case DBTYPE_FILETIME:
 934             return S_OK;
 935         default: return S_FALSE;
 936         }
 937
 938     case DBTYPE_ERROR:
 939         switch(dst_base_type)
 940         {
 941         case DBTYPE_BSTR:
 942         case DBTYPE_ERROR:
 943         case DBTYPE_VARIANT:
 944         case DBTYPE_WSTR:
 945             return S_OK;
 946         default: return S_FALSE;
 947         }
 948
 949     case DBTYPE_IUNKNOWN:
 950         switch(dst_base_type)
 951         {
 952         case DBTYPE_EMPTY:
 953         case DBTYPE_NULL:
 954         case DBTYPE_IDISPATCH:
 955         case DBTYPE_VARIANT:
 956         case DBTYPE_IUNKNOWN:
 957             return S_OK;
 958         default: return S_FALSE;
 959         }
 960
 961     case DBTYPE_BYTES:
 962         if(dst_class == DBTYPE_I4 || dst_class == DBTYPE_I8) return S_OK;
 963         /* fall through */
 964     case DBTYPE_GUID:
 965         switch(dst_class)
 966         {
 967         case DBTYPE_EMPTY:
 968         case DBTYPE_NULL:
 969         case DBTYPE_BSTR:
 970         case DBTYPE_VARIANT:
 971         case DBTYPE_GUID:
 972         case DBTYPE_BYTES:
 973             return S_OK;
 974         default: return S_FALSE;
 975         }
 976
 977     case DBTYPE_FILETIME:
 978         if(dst_class == DBTYPE_I8) return S_OK;
 979         /* fall through */
 980     case DBTYPE_DBDATE:
 981         switch(dst_class)
 982         {
 983         case DBTYPE_EMPTY:
 984         case DBTYPE_NULL:
 985         case DBTYPE_DATE:
 986         case DBTYPE_BSTR:
 987         case DBTYPE_VARIANT:
 988         case DBTYPE_DBDATE:
 989         case DBTYPE_FILETIME:
 990             return S_OK;
 991         default: return S_FALSE;
 992         }
 993
 994     }
 995     return S_FALSE;
 996 }
 997
 998 static HRESULT WINAPI convert_GetConversionSize(IDataConvert* iface,
 999                                                 DBTYPE wSrcType, DBTYPE wDstType,
1000                                                 DBLENGTH *pcbSrcLength, DBLENGTH *pcbDstLength,
1001                                                 void *pSrc)
1002 {
1003     convert *This = impl_from_IDataConvert(iface);
1004     FIXME("(%p)->(%d, %d, %p, %p, %p): stub\n", This, wSrcType, wDstType, pcbSrcLength, pcbDstLength, pSrc);
1005
1006     return E_NOTIMPL;
1007 }
1008
1009 static const struct IDataConvertVtbl convert_vtbl =
1010 {
1011     convert_QueryInterface,
1012     convert_AddRef,
1013     convert_Release,
1014     convert_DataConvert,
1015     convert_CanConvert,
1016     convert_GetConversionSize
1017 };
1018
1019 static HRESULT WINAPI dcinfo_QueryInterface(IDCInfo* iface, REFIID riid, void **obj)
1020 {
1021     convert *This = impl_from_IDCInfo(iface);
1022
1023     return IDataConvert_QueryInterface(&This->IDataConvert_iface, riid, obj);
1024 }
1025
1026 static ULONG WINAPI dcinfo_AddRef(IDCInfo* iface)
1027 {
1028     convert *This = impl_from_IDCInfo(iface);
1029
1030     return IDataConvert_AddRef(&This->IDataConvert_iface);
1031 }
1032
1033 static ULONG WINAPI dcinfo_Release(IDCInfo* iface)
1034 {
1035     convert *This = impl_from_IDCInfo(iface);
1036
1037     return IDataConvert_Release(&This->IDataConvert_iface);
1038 }
1039
1040 static HRESULT WINAPI dcinfo_GetInfo(IDCInfo *iface, ULONG num, DCINFOTYPE types[], DCINFO **info_ptr)
1041 {
1042     convert *This = impl_from_IDCInfo(iface);
1043     ULONG i;
1044     DCINFO *infos;
1045
1046     TRACE("(%p)->(%d, %p, %p)\n", This, num, types, info_ptr);
1047
1048     *info_ptr = infos = CoTaskMemAlloc(num * sizeof(*infos));
1049     if(!infos) return E_OUTOFMEMORY;
1050
1051     for(i = 0; i < num; i++)
1052     {
1053         infos[i].eInfoType = types[i];
1054         VariantInit(&infos[i].vData);
1055
1056         switch(types[i])
1057         {
1058         case DCINFOTYPE_VERSION:
1059             V_VT(&infos[i].vData) = VT_UI4;
1060             V_UI4(&infos[i].vData) = This->version;
1061             break;
1062         }
1063     }
1064
1065     return S_OK;
1066 }
1067
1068 static HRESULT WINAPI dcinfo_SetInfo(IDCInfo* iface, ULONG num, DCINFO info[])
1069 {
1070     convert *This = impl_from_IDCInfo(iface);
1071     ULONG i;
1072     HRESULT hr = S_OK;
1073
1074     TRACE("(%p)->(%d, %p)\n", This, num, info);
1075
1076     for(i = 0; i < num; i++)
1077     {
1078         switch(info[i].eInfoType)
1079         {
1080         case DCINFOTYPE_VERSION:
1081             if(V_VT(&info[i].vData) != VT_UI4)
1082             {
1083                 FIXME("VERSION with vt %x\n", V_VT(&info[i].vData));
1084                 hr = DB_S_ERRORSOCCURRED;
1085                 break;
1086             }
1087             This->version = V_UI4(&info[i].vData);
1088             break;
1089
1090         default:
1091             FIXME("Unhandled info type %d (vt %x)\n", info[i].eInfoType, V_VT(&info[i].vData));
1092         }
1093     }
1094     return hr;
1095 }
1096
1097 static const struct IDCInfoVtbl dcinfo_vtbl =
1098 {
1099     dcinfo_QueryInterface,
1100     dcinfo_AddRef,
1101     dcinfo_Release,
1102     dcinfo_GetInfo,
1103     dcinfo_SetInfo
1104 };
1105
1106 HRESULT create_oledb_convert(IUnknown *outer, void **obj)
1107 {
1108     convert *This;
1109
1110     TRACE("(%p, %p)\n", outer, obj);
1111
1112     *obj = NULL;
1113
1114     if(outer) return CLASS_E_NOAGGREGATION;
1115
1116     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1117     if(!This) return E_OUTOFMEMORY;
1118
1119     This->IDataConvert_iface.lpVtbl = &convert_vtbl;
1120     This->IDCInfo_iface.lpVtbl = &dcinfo_vtbl;
1121     This->ref = 1;
1122     This->version = 0x110;
1123
1124     *obj = &This->IDataConvert_iface;
1125
1126     return S_OK;
1127 }