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     case DBTYPE_R4:
 126         return 4;
 127     case DBTYPE_I8:
 128     case DBTYPE_UI8:
 129         return 8;
 130     case DBTYPE_CY:
 131         return sizeof(CY);
 132     case DBTYPE_BSTR:
 133         return sizeof(BSTR);
 134     case DBTYPE_FILETIME:
 135         return sizeof(FILETIME);
 136     case DBTYPE_GUID:
 137         return sizeof(GUID);
 138     case DBTYPE_WSTR:
 139     case DBTYPE_BYREF | DBTYPE_WSTR:
 140         return 0;
 141     default:
 142         FIXME("Unhandled type %04x\n", type);
 143         return 0;
 144     }
 145 }
 146
 147 static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
 148                                           DBTYPE src_type, DBTYPE dst_type,
 149                                           DBLENGTH src_len, DBLENGTH *dst_len,
 150                                           void *src, void *dst,
 151                                           DBLENGTH dst_max_len,
 152                                           DBSTATUS src_status, DBSTATUS *dst_status,
 153                                           BYTE precision, BYTE scale,
 154                                           DBDATACONVERT flags)
 155 {
 156     convert *This = impl_from_IDataConvert(iface);
 157     HRESULT hr;
 158
 159     TRACE("(%p)->(%d, %d, %d, %p, %p, %p, %d, %d, %p, %d, %d, %x)\n", This,
 160           src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
 161           src_status, dst_status, precision, scale, flags);
 162
 163     *dst_len = get_length(dst_type);
 164     *dst_status = DBSTATUS_E_BADACCESSOR;
 165
 166     if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
 167     {
 168         return DB_E_UNSUPPORTEDCONVERSION;
 169     }
 170
 171     if(src_type == DBTYPE_STR)
 172     {
 173         BSTR b;
 174         DWORD len;
 175
 176         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 177             len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
 178         else
 179             len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
 180         b = SysAllocStringLen(NULL, len);
 181         if(!b) return E_OUTOFMEMORY;
 182         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 183             MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
 184         else
 185             MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
 186
 187         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 188                                       &b, dst, dst_max_len, src_status, dst_status,
 189                                       precision, scale, flags);
 190
 191         SysFreeString(b);
 192         return hr;
 193     }
 194
 195     if(src_type == DBTYPE_WSTR)
 196     {
 197         BSTR b;
 198
 199         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 200             b = SysAllocString(src);
 201         else
 202             b = SysAllocStringLen(src, src_len / 2);
 203         if(!b) return E_OUTOFMEMORY;
 204         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 205                                       &b, dst, dst_max_len, src_status, dst_status,
 206                                       precision, scale, flags);
 207         SysFreeString(b);
 208         return hr;
 209     }
 210
 211     switch(dst_type)
 212     {
 213     case DBTYPE_I2:
 214     {
 215         signed short *d = dst;
 216         switch(src_type)
 217         {
 218         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 219         case DBTYPE_I2:          *d = *(signed short*)src; hr = S_OK;            break;
 220         case DBTYPE_I4:          hr = VarI2FromI4(*(signed int*)src, d);         break;
 221         case DBTYPE_R4:          hr = VarI2FromR4(*(FLOAT*)src, d);              break;
 222         case DBTYPE_R8:          hr = VarI2FromR8(*(double*)src, d);             break;
 223         case DBTYPE_CY:          hr = VarI2FromCy(*(CY*)src, d);                 break;
 224         case DBTYPE_DATE:        hr = VarI2FromDate(*(DATE*)src, d);             break;
 225         case DBTYPE_BSTR:        hr = VarI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 226         case DBTYPE_BOOL:        hr = VarI2FromBool(*(VARIANT_BOOL*)src, d);     break;
 227         case DBTYPE_DECIMAL:     hr = VarI2FromDec((DECIMAL*)src, d);            break;
 228         case DBTYPE_I1:          hr = VarI2FromI1(*(signed char*)src, d);        break;
 229         case DBTYPE_UI1:         hr = VarI2FromUI1(*(BYTE*)src, d);              break;
 230         case DBTYPE_UI2:         hr = VarI2FromUI2(*(WORD*)src, d);              break;
 231         case DBTYPE_UI4:         hr = VarI2FromUI4(*(DWORD*)src, d);             break;
 232         case DBTYPE_I8:          hr = VarI2FromI8(*(LONGLONG*)src, d);           break;
 233         case DBTYPE_UI8:         hr = VarI2FromUI8(*(ULONGLONG*)src, d);         break;
 234         default: FIXME("Unimplemented conversion %04x -> I2\n", src_type); return E_NOTIMPL;
 235         }
 236         break;
 237     }
 238
 239     case DBTYPE_I4:
 240     {
 241         signed int *d = dst;
 242         switch(src_type)
 243         {
 244         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 245         case DBTYPE_I2:          hr = VarI4FromI2(*(signed short*)src, d);       break;
 246         case DBTYPE_I4:          *d = *(signed int*)src; hr = S_OK;              break;
 247         case DBTYPE_R4:          hr = VarI4FromR4(*(FLOAT*)src, d);              break;
 248         case DBTYPE_R8:          hr = VarI4FromR8(*(double*)src, d);             break;
 249         case DBTYPE_CY:          hr = VarI4FromCy(*(CY*)src, d);                 break;
 250         case DBTYPE_DATE:        hr = VarI4FromDate(*(DATE*)src, d);             break;
 251         case DBTYPE_BSTR:        hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 252         case DBTYPE_BOOL:        hr = VarI4FromBool(*(VARIANT_BOOL*)src, d);     break;
 253         case DBTYPE_DECIMAL:     hr = VarI4FromDec((DECIMAL*)src, d);            break;
 254         case DBTYPE_I1:          hr = VarI4FromI1(*(signed char*)src, d);        break;
 255         case DBTYPE_UI1:         hr = VarI4FromUI1(*(BYTE*)src, d);              break;
 256         case DBTYPE_UI2:         hr = VarI4FromUI2(*(WORD*)src, d);              break;
 257         case DBTYPE_UI4:         hr = VarI4FromUI4(*(DWORD*)src, d);             break;
 258         case DBTYPE_I8:          hr = VarI4FromI8(*(LONGLONG*)src, d);           break;
 259         case DBTYPE_UI8:         hr = VarI4FromUI8(*(ULONGLONG*)src, d);         break;
 260         default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
 261         }
 262         break;
 263     }
 264
 265     case DBTYPE_R4:
 266     {
 267         FLOAT *d = dst;
 268         switch(src_type)
 269         {
 270         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 271         case DBTYPE_I2:          hr = VarR4FromI2(*(signed short*)src, d);       break;
 272         case DBTYPE_I4:          hr = VarR4FromI4(*(signed int*)src, d);         break;
 273         case DBTYPE_R4:          *d = *(FLOAT*)src; hr = S_OK;                   break;
 274         case DBTYPE_R8:          hr = VarR4FromR8(*(double*)src, d);             break;
 275         case DBTYPE_CY:          hr = VarR4FromCy(*(CY*)src, d);                 break;
 276         case DBTYPE_DATE:        hr = VarR4FromDate(*(DATE*)src, d);             break;
 277         case DBTYPE_BSTR:        hr = VarR4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 278         case DBTYPE_BOOL:        hr = VarR4FromBool(*(VARIANT_BOOL*)src, d);     break;
 279         case DBTYPE_DECIMAL:     hr = VarR4FromDec((DECIMAL*)src, d);            break;
 280         case DBTYPE_I1:          hr = VarR4FromI1(*(signed char*)src, d);        break;
 281         case DBTYPE_UI1:         hr = VarR4FromUI1(*(BYTE*)src, d);              break;
 282         case DBTYPE_UI2:         hr = VarR4FromUI2(*(WORD*)src, d);              break;
 283         case DBTYPE_UI4:         hr = VarR4FromUI4(*(DWORD*)src, d);             break;
 284         case DBTYPE_I8:          hr = VarR4FromI8(*(LONGLONG*)src, d);           break;
 285         case DBTYPE_UI8:         hr = VarR4FromUI8(*(ULONGLONG*)src, d);         break;
 286         default: FIXME("Unimplemented conversion %04x -> R4\n", src_type); return E_NOTIMPL;
 287         }
 288         break;
 289     }
 290
 291     case DBTYPE_CY:
 292     {
 293         CY *d = dst;
 294         switch(src_type)
 295         {
 296         case DBTYPE_EMPTY:       d->int64 = 0; hr = S_OK;                              break;
 297         case DBTYPE_I2:          hr = VarCyFromI2(*(signed short*)src, d);       break;
 298         case DBTYPE_I4:          hr = VarCyFromI4(*(signed int*)src, d);         break;
 299         case DBTYPE_R4:          hr = VarCyFromR4(*(FLOAT*)src, d);              break;
 300         case DBTYPE_R8:          hr = VarCyFromR8(*(double*)src, d);             break;
 301         case DBTYPE_CY:          *d = *(CY*)src; hr = S_OK;                      break;
 302         case DBTYPE_DATE:        hr = VarCyFromDate(*(DATE*)src, d);             break;
 303         case DBTYPE_BSTR:        hr = VarCyFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 304         case DBTYPE_BOOL:        hr = VarCyFromBool(*(VARIANT_BOOL*)src, d);     break;
 305         case DBTYPE_DECIMAL:     hr = VarCyFromDec((DECIMAL*)src, d);            break;
 306         case DBTYPE_I1:          hr = VarCyFromI1(*(signed char*)src, d);        break;
 307         case DBTYPE_UI1:         hr = VarCyFromUI1(*(BYTE*)src, d);              break;
 308         case DBTYPE_UI2:         hr = VarCyFromUI2(*(WORD*)src, d);              break;
 309         case DBTYPE_UI4:         hr = VarCyFromUI4(*(DWORD*)src, d);             break;
 310         case DBTYPE_I8:          hr = VarCyFromI8(*(LONGLONG*)src, d);           break;
 311         case DBTYPE_UI8:         hr = VarCyFromUI8(*(ULONGLONG*)src, d);         break;
 312         default: FIXME("Unimplemented conversion %04x -> CY\n", src_type); return E_NOTIMPL;
 313         }
 314         break;
 315     }
 316
 317     case DBTYPE_BSTR:
 318     {
 319         BSTR *d = dst;
 320         switch(src_type)
 321         {
 322         case DBTYPE_EMPTY:       *d = SysAllocStringLen(NULL, 0); hr = *d ? S_OK : E_OUTOFMEMORY;      break;
 323         case DBTYPE_I2:          hr = VarBstrFromI2(*(signed short*)src, LOCALE_USER_DEFAULT, 0, d);   break;
 324         case DBTYPE_I4:          hr = VarBstrFromI4(*(signed int*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 325         case DBTYPE_R4:          hr = VarBstrFromR4(*(FLOAT*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 326         case DBTYPE_R8:          hr = VarBstrFromR8(*(double*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 327         case DBTYPE_CY:          hr = VarBstrFromCy(*(CY*)src, LOCALE_USER_DEFAULT, 0, d);             break;
 328         case DBTYPE_DATE:        hr = VarBstrFromDate(*(DATE*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 329         case DBTYPE_BSTR:        *d = SysAllocStringLen(*(BSTR*)src, SysStringLen(*(BSTR*)src)); hr = *d ? S_OK : E_OUTOFMEMORY;     break;
 330         case DBTYPE_BOOL:        hr = VarBstrFromBool(*(VARIANT_BOOL*)src, LOCALE_USER_DEFAULT, 0, d); break;
 331         case DBTYPE_DECIMAL:     hr = VarBstrFromDec((DECIMAL*)src, LOCALE_USER_DEFAULT, 0, d);        break;
 332         case DBTYPE_I1:          hr = VarBstrFromI1(*(signed char*)src, LOCALE_USER_DEFAULT, 0, d);    break;
 333         case DBTYPE_UI1:         hr = VarBstrFromUI1(*(BYTE*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 334         case DBTYPE_UI2:         hr = VarBstrFromUI2(*(WORD*)src, LOCALE_USER_DEFAULT, 0, d);          break;
 335         case DBTYPE_UI4:         hr = VarBstrFromUI4(*(DWORD*)src, LOCALE_USER_DEFAULT, 0, d);         break;
 336         case DBTYPE_I8:          hr = VarBstrFromI8(*(LONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);       break;
 337         case DBTYPE_UI8:         hr = VarBstrFromUI8(*(ULONGLONG*)src, LOCALE_USER_DEFAULT, 0, d);     break;
 338         default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type); return E_NOTIMPL;
 339         }
 340         break;
 341     }
 342
 343     case DBTYPE_UI1:
 344     {
 345         BYTE *d = dst;
 346         switch(src_type)
 347         {
 348         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 349         case DBTYPE_I2:          hr = VarUI1FromI2(*(signed short*)src, d);      break;
 350         case DBTYPE_I4:          hr = VarUI1FromI4(*(signed int*)src, d);        break;
 351         case DBTYPE_R4:          hr = VarUI1FromR4(*(FLOAT*)src, d);             break;
 352         case DBTYPE_R8:          hr = VarUI1FromR8(*(double*)src, d);            break;
 353         case DBTYPE_CY:          hr = VarUI1FromCy(*(CY*)src, d);                break;
 354         case DBTYPE_DATE:        hr = VarUI1FromDate(*(DATE*)src, d);            break;
 355         case DBTYPE_BSTR:        hr = VarUI1FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 356         case DBTYPE_BOOL:        hr = VarUI1FromBool(*(VARIANT_BOOL*)src, d);    break;
 357         case DBTYPE_DECIMAL:     hr = VarUI1FromDec((DECIMAL*)src, d);           break;
 358         case DBTYPE_I1:          hr = VarUI1FromI1(*(signed char*)src, d);       break;
 359         case DBTYPE_UI1:         *d = *(BYTE*)src; hr = S_OK;                    break;
 360         case DBTYPE_UI2:         hr = VarUI1FromUI2(*(WORD*)src, d);             break;
 361         case DBTYPE_UI4:         hr = VarUI1FromUI4(*(DWORD*)src, d);            break;
 362         case DBTYPE_I8:          hr = VarUI1FromI8(*(LONGLONG*)src, d);          break;
 363         case DBTYPE_UI8:         hr = VarUI1FromUI8(*(ULONGLONG*)src, d);        break;
 364         default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type); return E_NOTIMPL;
 365         }
 366         break;
 367     }
 368
 369     case DBTYPE_UI4:
 370     {
 371         DWORD *d = dst;
 372         switch(src_type)
 373         {
 374         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 375         case DBTYPE_I2:          hr = VarUI4FromI2(*(signed short*)src, d);      break;
 376         case DBTYPE_I4:          hr = VarUI4FromI4(*(signed int*)src, d);        break;
 377         case DBTYPE_R4:          hr = VarUI4FromR4(*(FLOAT*)src, d);             break;
 378         case DBTYPE_R8:          hr = VarUI4FromR8(*(double*)src, d);            break;
 379         case DBTYPE_CY:          hr = VarUI4FromCy(*(CY*)src, d);                break;
 380         case DBTYPE_DATE:        hr = VarUI4FromDate(*(DATE*)src, d);            break;
 381         case DBTYPE_BSTR:        hr = VarUI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 382         case DBTYPE_BOOL:        hr = VarUI4FromBool(*(VARIANT_BOOL*)src, d);    break;
 383         case DBTYPE_DECIMAL:     hr = VarUI4FromDec((DECIMAL*)src, d);           break;
 384         case DBTYPE_I1:          hr = VarUI4FromI1(*(signed char*)src, d);       break;
 385         case DBTYPE_UI1:         hr = VarUI4FromUI1(*(BYTE*)src, d);             break;
 386         case DBTYPE_UI2:         hr = VarUI4FromUI2(*(WORD*)src, d);             break;
 387         case DBTYPE_UI4:         *d = *(DWORD*)src; hr = S_OK;                   break;
 388         case DBTYPE_I8:          hr = VarUI4FromI8(*(LONGLONG*)src, d);          break;
 389         case DBTYPE_UI8:         hr = VarUI4FromUI8(*(ULONGLONG*)src, d);        break;
 390         default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type); return E_NOTIMPL;
 391         }
 392         break;
 393     }
 394
 395     case DBTYPE_UI8:
 396     {
 397         ULONGLONG *d = dst;
 398         switch(src_type)
 399         {
 400         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 401         case DBTYPE_I2:          hr = VarUI8FromI2(*(signed short*)src, d);      break;
 402         case DBTYPE_I4:          {LONGLONG s = *(signed int*)src; hr = VarUI8FromI8(s, d);        break;}
 403         case DBTYPE_R4:          hr = VarUI8FromR4(*(FLOAT*)src, d);             break;
 404         case DBTYPE_R8:          hr = VarUI8FromR8(*(double*)src, d);            break;
 405         case DBTYPE_CY:          hr = VarUI8FromCy(*(CY*)src, d);                break;
 406         case DBTYPE_DATE:        hr = VarUI8FromDate(*(DATE*)src, d);            break;
 407         case DBTYPE_BSTR:        hr = VarUI8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 408         case DBTYPE_BOOL:        hr = VarUI8FromBool(*(VARIANT_BOOL*)src, d);    break;
 409         case DBTYPE_DECIMAL:     hr = VarUI8FromDec((DECIMAL*)src, d);           break;
 410         case DBTYPE_I1:          hr = VarUI8FromI1(*(signed char*)src, d);       break;
 411         case DBTYPE_UI1:         hr = VarUI8FromUI1(*(BYTE*)src, d);             break;
 412         case DBTYPE_UI2:         hr = VarUI8FromUI2(*(WORD*)src, d);             break;
 413         case DBTYPE_UI4:         hr = VarUI8FromUI4(*(DWORD*)src, d);            break;
 414         case DBTYPE_I8:          hr = VarUI8FromI8(*(LONGLONG*)src, d);          break;
 415         case DBTYPE_UI8:         *d = *(ULONGLONG*)src; hr = S_OK;               break;
 416         default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type); return E_NOTIMPL;
 417         }
 418         break;
 419     }
 420
 421     case DBTYPE_FILETIME:
 422     {
 423         FILETIME *d = dst;
 424         switch(src_type)
 425         {
 426         case DBTYPE_EMPTY:       d->dwLowDateTime = d->dwHighDateTime = 0; hr = S_OK;    break;
 427         case DBTYPE_FILETIME:    *d = *(FILETIME*)src; hr = S_OK;                        break;
 428         default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type); return E_NOTIMPL;
 429         }
 430         break;
 431     }
 432
 433     case DBTYPE_GUID:
 434     {
 435         GUID *d = dst;
 436         switch(src_type)
 437         {
 438         case DBTYPE_EMPTY:       *d = GUID_NULL; hr = S_OK; break;
 439         case DBTYPE_GUID:        *d = *(GUID*)src; hr = S_OK; break;
 440         default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type); return E_NOTIMPL;
 441         }
 442         break;
 443     }
 444
 445     case DBTYPE_WSTR:
 446     {
 447         BSTR b;
 448         DBLENGTH bstr_len;
 449         INT bytes_to_copy;
 450         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 451                                       src, &b, sizeof(BSTR), src_status, dst_status,
 452                                       precision, scale, flags);
 453         if(hr != S_OK) return hr;
 454         bstr_len = SysStringLen(b);
 455         *dst_len = bstr_len * sizeof(WCHAR); /* Doesn't include size for '\0' */
 456         *dst_status = DBSTATUS_S_OK;
 457         bytes_to_copy = min(*dst_len + sizeof(WCHAR), dst_max_len);
 458         if(dst)
 459         {
 460             if(bytes_to_copy >= sizeof(WCHAR))
 461             {
 462                 memcpy(dst, b, bytes_to_copy - sizeof(WCHAR));
 463                 *((WCHAR*)dst + bytes_to_copy / sizeof(WCHAR) - 1) = 0;
 464                 if(bytes_to_copy < *dst_len + sizeof(WCHAR))
 465                     *dst_status = DBSTATUS_S_TRUNCATED;
 466             }
 467             else
 468             {
 469                 *dst_status = DBSTATUS_E_DATAOVERFLOW;
 470                 hr = DB_E_ERRORSOCCURRED;
 471             }
 472         }
 473         SysFreeString(b);
 474         return hr;
 475     }
 476
 477     case DBTYPE_BYREF | DBTYPE_WSTR:
 478     {
 479         BSTR b;
 480         WCHAR **d = dst;
 481         DBLENGTH bstr_len;
 482         hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
 483                                       src, &b, sizeof(BSTR), src_status, dst_status,
 484                                       precision, scale, flags);
 485         if(hr != S_OK) return hr;
 486
 487         bstr_len = SysStringLen(b) * sizeof(WCHAR);
 488         *dst_len = bstr_len; /* Doesn't include size for '\0' */
 489
 490         *d = CoTaskMemAlloc(bstr_len + sizeof(WCHAR));
 491         if(*d) memcpy(*d, b, bstr_len + sizeof(WCHAR));
 492         else hr = E_OUTOFMEMORY;
 493         SysFreeString(b);
 494         return hr;
 495     }
 496
 497     default:
 498         FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
 499         return E_NOTIMPL;
 500
 501     }
 502
 503     if(hr == DISP_E_OVERFLOW)
 504     {
 505         *dst_status = DBSTATUS_E_DATAOVERFLOW;
 506         hr = DB_E_ERRORSOCCURRED;
 507     }
 508     else if(hr == S_OK)
 509         *dst_status = DBSTATUS_S_OK;
 510
 511     return hr;
 512 }
 513
 514 static inline WORD get_dbtype_class(DBTYPE type)
 515 {
 516     switch(type)
 517     {
 518     case DBTYPE_I2:
 519     case DBTYPE_R4:
 520     case DBTYPE_R8:
 521     case DBTYPE_I1:
 522     case DBTYPE_UI1:
 523     case DBTYPE_UI2:
 524         return DBTYPE_I2;
 525
 526     case DBTYPE_I4:
 527     case DBTYPE_UI4:
 528         return DBTYPE_I4;
 529
 530     case DBTYPE_I8:
 531     case DBTYPE_UI8:
 532         return DBTYPE_I8;
 533
 534     case DBTYPE_BSTR:
 535     case DBTYPE_STR:
 536     case DBTYPE_WSTR:
 537         return DBTYPE_BSTR;
 538
 539     case DBTYPE_DBDATE:
 540     case DBTYPE_DBTIME:
 541     case DBTYPE_DBTIMESTAMP:
 542         return DBTYPE_DBDATE;
 543     }
 544     return type;
 545 }
 546
 547 /* Many src types will convert to this group of dst types */
 548 static inline BOOL common_class(WORD dst_class)
 549 {
 550     switch(dst_class)
 551     {
 552     case DBTYPE_EMPTY:
 553     case DBTYPE_NULL:
 554     case DBTYPE_I2:
 555     case DBTYPE_I4:
 556     case DBTYPE_BSTR:
 557     case DBTYPE_BOOL:
 558     case DBTYPE_VARIANT:
 559     case DBTYPE_I8:
 560     case DBTYPE_CY:
 561     case DBTYPE_DECIMAL:
 562     case DBTYPE_NUMERIC:
 563         return TRUE;
 564     }
 565     return FALSE;
 566 }
 567
 568 static inline BOOL array_type(DBTYPE type)
 569 {
 570     return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
 571 }
 572
 573 static HRESULT WINAPI convert_CanConvert(IDataConvert* iface,
 574                                          DBTYPE src_type, DBTYPE dst_type)
 575 {
 576     convert *This = impl_from_IDataConvert(iface);
 577     DBTYPE src_base_type = src_type & 0x1ff;
 578     DBTYPE dst_base_type = dst_type & 0x1ff;
 579     WORD dst_class = get_dbtype_class(dst_base_type);
 580
 581     TRACE("(%p)->(%d, %d)\n", This, src_type, dst_type);
 582
 583     if(src_type & DBTYPE_VECTOR || dst_type & DBTYPE_VECTOR) return S_FALSE;
 584
 585     if(src_type & DBTYPE_ARRAY)
 586     {
 587         if(!array_type(src_base_type)) return S_FALSE;
 588         if(dst_type & DBTYPE_ARRAY)
 589         {
 590             if(src_type == dst_type) return S_OK;
 591             return S_FALSE;
 592         }
 593         if(dst_type == DBTYPE_VARIANT) return S_OK;
 594         return S_FALSE;
 595     }
 596
 597     if(dst_type & DBTYPE_ARRAY)
 598     {
 599         if(!array_type(dst_base_type)) return S_FALSE;
 600         if(src_type == DBTYPE_IDISPATCH || src_type == DBTYPE_VARIANT) return S_OK;
 601         return S_FALSE;
 602     }
 603
 604     if(dst_type & DBTYPE_BYREF)
 605         if(dst_base_type != DBTYPE_BYTES && dst_base_type != DBTYPE_STR && dst_base_type != DBTYPE_WSTR)
 606             return S_FALSE;
 607
 608     switch(get_dbtype_class(src_base_type))
 609     {
 610     case DBTYPE_EMPTY:
 611         if(common_class(dst_class)) return S_OK;
 612         switch(dst_class)
 613         {
 614         case DBTYPE_DATE:
 615         case DBTYPE_GUID:
 616         case DBTYPE_FILETIME:
 617             return S_OK;
 618         default:
 619             if(dst_base_type == DBTYPE_DBTIMESTAMP) return S_OK;
 620             return S_FALSE;
 621         }
 622
 623     case DBTYPE_NULL:
 624         switch(dst_base_type)
 625         {
 626         case DBTYPE_NULL:
 627         case DBTYPE_VARIANT:
 628         case DBTYPE_FILETIME: return S_OK;
 629         default: return S_FALSE;
 630         }
 631
 632     case DBTYPE_I4:
 633         if(dst_base_type == DBTYPE_BYTES) return S_OK;
 634         /* fall through */
 635     case DBTYPE_I2:
 636         if(dst_base_type == DBTYPE_DATE) return S_OK;
 637         /* fall through */
 638     case DBTYPE_DECIMAL:
 639         if(common_class(dst_class)) return S_OK;
 640         if(dst_class == DBTYPE_DBDATE) return S_OK;
 641         return S_FALSE;
 642
 643     case DBTYPE_BOOL:
 644         if(dst_base_type == DBTYPE_DATE) return S_OK;
 645     case DBTYPE_NUMERIC:
 646     case DBTYPE_CY:
 647         if(common_class(dst_class)) return S_OK;
 648         return S_FALSE;
 649
 650     case DBTYPE_I8:
 651         if(common_class(dst_class)) return S_OK;
 652         switch(dst_base_type)
 653         {
 654         case DBTYPE_BYTES:
 655         case DBTYPE_FILETIME: return S_OK;
 656         default: return S_FALSE;
 657         }
 658
 659     case DBTYPE_DATE:
 660         switch(dst_class)
 661         {
 662         case DBTYPE_EMPTY:
 663         case DBTYPE_NULL:
 664         case DBTYPE_I2:
 665         case DBTYPE_I4:
 666         case DBTYPE_BSTR:
 667         case DBTYPE_BOOL:
 668         case DBTYPE_VARIANT:
 669         case DBTYPE_I8:
 670         case DBTYPE_DATE:
 671         case DBTYPE_DBDATE:
 672         case DBTYPE_FILETIME:
 673             return S_OK;
 674         default: return S_FALSE;
 675         }
 676
 677     case DBTYPE_IDISPATCH:
 678     case DBTYPE_VARIANT:
 679         switch(dst_base_type)
 680         {
 681         case DBTYPE_IDISPATCH:
 682         case DBTYPE_ERROR:
 683         case DBTYPE_IUNKNOWN:
 684             return S_OK;
 685         }
 686         /* fall through */
 687     case DBTYPE_BSTR:
 688         if(common_class(dst_class)) return S_OK;
 689         switch(dst_class)
 690         {
 691         case DBTYPE_DATE:
 692         case DBTYPE_GUID:
 693         case DBTYPE_BYTES:
 694         case DBTYPE_DBDATE:
 695         case DBTYPE_FILETIME:
 696             return S_OK;
 697         default: return S_FALSE;
 698         }
 699
 700     case DBTYPE_ERROR:
 701         switch(dst_base_type)
 702         {
 703         case DBTYPE_BSTR:
 704         case DBTYPE_ERROR:
 705         case DBTYPE_VARIANT:
 706         case DBTYPE_WSTR:
 707             return S_OK;
 708         default: return S_FALSE;
 709         }
 710
 711     case DBTYPE_IUNKNOWN:
 712         switch(dst_base_type)
 713         {
 714         case DBTYPE_EMPTY:
 715         case DBTYPE_NULL:
 716         case DBTYPE_IDISPATCH:
 717         case DBTYPE_VARIANT:
 718         case DBTYPE_IUNKNOWN:
 719             return S_OK;
 720         default: return S_FALSE;
 721         }
 722
 723     case DBTYPE_BYTES:
 724         if(dst_class == DBTYPE_I4 || dst_class == DBTYPE_I8) return S_OK;
 725         /* fall through */
 726     case DBTYPE_GUID:
 727         switch(dst_class)
 728         {
 729         case DBTYPE_EMPTY:
 730         case DBTYPE_NULL:
 731         case DBTYPE_BSTR:
 732         case DBTYPE_VARIANT:
 733         case DBTYPE_GUID:
 734         case DBTYPE_BYTES:
 735             return S_OK;
 736         default: return S_FALSE;
 737         }
 738
 739     case DBTYPE_FILETIME:
 740         if(dst_class == DBTYPE_I8) return S_OK;
 741         /* fall through */
 742     case DBTYPE_DBDATE:
 743         switch(dst_class)
 744         {
 745         case DBTYPE_EMPTY:
 746         case DBTYPE_NULL:
 747         case DBTYPE_DATE:
 748         case DBTYPE_BSTR:
 749         case DBTYPE_VARIANT:
 750         case DBTYPE_DBDATE:
 751         case DBTYPE_FILETIME:
 752             return S_OK;
 753         default: return S_FALSE;
 754         }
 755
 756     }
 757     return S_FALSE;
 758 }
 759
 760 static HRESULT WINAPI convert_GetConversionSize(IDataConvert* iface,
 761                                                 DBTYPE wSrcType, DBTYPE wDstType,
 762                                                 DBLENGTH *pcbSrcLength, DBLENGTH *pcbDstLength,
 763                                                 void *pSrc)
 764 {
 765     convert *This = impl_from_IDataConvert(iface);
 766     FIXME("(%p)->(%d, %d, %p, %p, %p): stub\n", This, wSrcType, wDstType, pcbSrcLength, pcbDstLength, pSrc);
 767
 768     return E_NOTIMPL;
 769 }
 770
 771 static const struct IDataConvertVtbl convert_vtbl =
 772 {
 773     convert_QueryInterface,
 774     convert_AddRef,
 775     convert_Release,
 776     convert_DataConvert,
 777     convert_CanConvert,
 778     convert_GetConversionSize
 779 };
 780
 781 static HRESULT WINAPI dcinfo_QueryInterface(IDCInfo* iface, REFIID riid, void **obj)
 782 {
 783     convert *This = impl_from_IDCInfo(iface);
 784
 785     return IDataConvert_QueryInterface((IDataConvert *)This, riid, obj);
 786 }
 787
 788 static ULONG WINAPI dcinfo_AddRef(IDCInfo* iface)
 789 {
 790     convert *This = impl_from_IDCInfo(iface);
 791
 792     return IDataConvert_AddRef((IDataConvert *)This);
 793 }
 794
 795 static ULONG WINAPI dcinfo_Release(IDCInfo* iface)
 796 {
 797     convert *This = impl_from_IDCInfo(iface);
 798
 799     return IDataConvert_Release((IDataConvert *)This);
 800 }
 801
 802 static HRESULT WINAPI dcinfo_GetInfo(IDCInfo *iface, ULONG num, DCINFOTYPE types[], DCINFO **info_ptr)
 803 {
 804     convert *This = impl_from_IDCInfo(iface);
 805     ULONG i;
 806     DCINFO *infos;
 807
 808     TRACE("(%p)->(%d, %p, %p)\n", This, num, types, info_ptr);
 809
 810     *info_ptr = infos = CoTaskMemAlloc(num * sizeof(*infos));
 811     if(!infos) return E_OUTOFMEMORY;
 812
 813     for(i = 0; i < num; i++)
 814     {
 815         infos[i].eInfoType = types[i];
 816         VariantInit(&infos[i].vData);
 817
 818         switch(types[i])
 819         {
 820         case DCINFOTYPE_VERSION:
 821             V_VT(&infos[i].vData) = VT_UI4;
 822             V_UI4(&infos[i].vData) = This->version;
 823             break;
 824         }
 825     }
 826
 827     return S_OK;
 828 }
 829
 830 static HRESULT WINAPI dcinfo_SetInfo(IDCInfo* iface, ULONG num, DCINFO info[])
 831 {
 832     convert *This = impl_from_IDCInfo(iface);
 833     ULONG i;
 834     HRESULT hr = S_OK;
 835
 836     TRACE("(%p)->(%d, %p)\n", This, num, info);
 837
 838     for(i = 0; i < num; i++)
 839     {
 840         switch(info[i].eInfoType)
 841         {
 842         case DCINFOTYPE_VERSION:
 843             if(V_VT(&info[i].vData) != VT_UI4)
 844             {
 845                 FIXME("VERSION with vt %x\n", V_VT(&info[i].vData));
 846                 hr = DB_S_ERRORSOCCURRED;
 847                 break;
 848             }
 849             This->version = V_UI4(&info[i].vData);
 850             break;
 851
 852         default:
 853             FIXME("Unhandled info type %d (vt %x)\n", info[i].eInfoType, V_VT(&info[i].vData));
 854         }
 855     }
 856     return hr;
 857 }
 858
 859 static const struct IDCInfoVtbl dcinfo_vtbl =
 860 {
 861     dcinfo_QueryInterface,
 862     dcinfo_AddRef,
 863     dcinfo_Release,
 864     dcinfo_GetInfo,
 865     dcinfo_SetInfo
 866 };
 867
 868 HRESULT create_oledb_convert(IUnknown *outer, void **obj)
 869 {
 870     convert *This;
 871
 872     TRACE("(%p, %p)\n", outer, obj);
 873
 874     *obj = NULL;
 875
 876     if(outer) return CLASS_E_NOAGGREGATION;
 877
 878     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 879     if(!This) return E_OUTOFMEMORY;
 880
 881     This->lpVtbl = &convert_vtbl;
 882     This->lpDCInfoVtbl = &dcinfo_vtbl;
 883     This->ref = 1;
 884     This->version = 0x110;
 885
 886     *obj = &This->lpVtbl;
 887
 888     return S_OK;
 889 }