1 /* OLE DB Conversion library
3 * Copyright 2009 Huw Davies
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.
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.
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
23 #define NONAMELESSUNION
24 #define NONAMELESSSTRUCT
33 #include "oledb_private.h"
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(oledb
);
41 IDataConvert IDataConvert_iface
;
42 IDCInfo IDCInfo_iface
;
46 UINT version
; /* Set by IDCInfo_SetInfo */
49 static inline convert
*impl_from_IDataConvert(IDataConvert
*iface
)
51 return CONTAINING_RECORD(iface
, convert
, IDataConvert_iface
);
54 static inline convert
*impl_from_IDCInfo(IDCInfo
*iface
)
56 return CONTAINING_RECORD(iface
, convert
, IDCInfo_iface
);
59 static HRESULT WINAPI
convert_QueryInterface(IDataConvert
* iface
,
63 convert
*This
= impl_from_IDataConvert(iface
);
64 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), obj
);
68 if(IsEqualIID(riid
, &IID_IUnknown
) ||
69 IsEqualIID(riid
, &IID_IDataConvert
))
73 else if(IsEqualIID(riid
, &IID_IDCInfo
))
75 *obj
= &This
->IDCInfo_iface
;
79 FIXME("interface %s not implemented\n", debugstr_guid(riid
));
83 IDataConvert_AddRef(iface
);
88 static ULONG WINAPI
convert_AddRef(IDataConvert
* iface
)
90 convert
*This
= impl_from_IDataConvert(iface
);
91 TRACE("(%p)\n", This
);
93 return InterlockedIncrement(&This
->ref
);
97 static ULONG WINAPI
convert_Release(IDataConvert
* iface
)
99 convert
*This
= impl_from_IDataConvert(iface
);
102 TRACE("(%p)\n", This
);
104 ref
= InterlockedDecrement(&This
->ref
);
107 HeapFree(GetProcessHeap(), 0, This
);
113 static int get_length(DBTYPE type
)
124 return sizeof(VARIANT_BOOL
);
134 case DBTYPE_DBTIMESTAMP
:
135 return sizeof(DBTIMESTAMP
);
140 case DBTYPE_FILETIME
:
141 return sizeof(FILETIME
);
146 case DBTYPE_BYREF
| DBTYPE_WSTR
:
149 FIXME("Unhandled type %04x\n", type
);
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
,
163 convert
*This
= impl_from_IDataConvert(iface
);
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
);
170 *dst_status
= DBSTATUS_E_BADACCESSOR
;
172 if(IDataConvert_CanConvert(iface
, src_type
, dst_type
) != S_OK
)
174 return DB_E_UNSUPPORTEDCONVERSION
;
177 if(src_type
== DBTYPE_STR
)
182 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
183 len
= MultiByteToWideChar(CP_ACP
, 0, src
, -1, NULL
, 0) - 1;
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);
191 MultiByteToWideChar(CP_ACP
, 0, src
, src_len
, b
, len
);
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
);
201 if(src_type
== DBTYPE_WSTR
)
205 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
206 b
= SysAllocString(src
);
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
);
221 signed short *d
= dst
;
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;
243 if ((hr
= VariantChangeType(&tmp
, (VARIANT
*)src
, 0, VT_I2
)) == S_OK
)
246 default: FIXME("Unimplemented conversion %04x -> I2\n", src_type
); return E_NOTIMPL
;
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;
275 if ((hr
= VariantChangeType(&tmp
, (VARIANT
*)src
, 0, VT_I4
)) == S_OK
)
278 default: FIXME("Unimplemented conversion %04x -> I4\n", src_type
); return E_NOTIMPL
;
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
;
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
;
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
;
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
:
382 DBTIMESTAMP
*ts
=(DBTIMESTAMP
*)src
;
385 st
.wMonth
= ts
->month
;
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
);
394 default: FIXME("Unimplemented conversion %04x -> DATE\n", src_type
); return E_NOTIMPL
;
398 case DBTYPE_DBTIMESTAMP
:
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;
408 hr
= (VariantTimeToSystemTime(*(double*)src
, &st
) ? S_OK
: E_FAIL
);
410 d
->month
= st
.wMonth
;
413 d
->minute
= st
.wMinute
;
414 d
->second
= st
.wSecond
;
415 d
->fraction
= st
.wMilliseconds
* 1000000;
418 default: FIXME("Unimplemented conversion %04x -> DBTIMESTAMP\n", src_type
); return E_NOTIMPL
;
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
;
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;
473 const GUID
*id
= (const GUID
*)src
;
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
;
488 *d
= SysAllocStringLen(NULL
, 2 * src_len
);
493 const char hexchars
[] = "0123456789ABCDEF";
495 unsigned char *p
= src
;
498 *s
++ = hexchars
[(*p
>> 4) & 0x0F];
499 *s
++ = hexchars
[(*p
) & 0x0F];
506 default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type
); return E_NOTIMPL
;
516 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
517 case DBTYPE_I2
: hr
= VarUI1FromI2(*(signed short*)src
, d
); break;
518 case DBTYPE_I4
: hr
= VarUI1FromI4(*(signed int*)src
, d
); break;
519 case DBTYPE_R4
: hr
= VarUI1FromR4(*(FLOAT
*)src
, d
); break;
520 case DBTYPE_R8
: hr
= VarUI1FromR8(*(double*)src
, d
); break;
521 case DBTYPE_CY
: hr
= VarUI1FromCy(*(CY
*)src
, d
); break;
522 case DBTYPE_DATE
: hr
= VarUI1FromDate(*(DATE
*)src
, d
); break;
523 case DBTYPE_BSTR
: hr
= VarUI1FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
524 case DBTYPE_BOOL
: hr
= VarUI1FromBool(*(VARIANT_BOOL
*)src
, d
); break;
525 case DBTYPE_DECIMAL
: hr
= VarUI1FromDec((DECIMAL
*)src
, d
); break;
526 case DBTYPE_I1
: hr
= VarUI1FromI1(*(signed char*)src
, d
); break;
527 case DBTYPE_UI1
: *d
= *(BYTE
*)src
; hr
= S_OK
; break;
528 case DBTYPE_UI2
: hr
= VarUI1FromUI2(*(WORD
*)src
, d
); break;
529 case DBTYPE_UI4
: hr
= VarUI1FromUI4(*(DWORD
*)src
, d
); break;
530 case DBTYPE_I8
: hr
= VarUI1FromI8(*(LONGLONG
*)src
, d
); break;
531 case DBTYPE_UI8
: hr
= VarUI1FromUI8(*(ULONGLONG
*)src
, d
); break;
532 default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type
); return E_NOTIMPL
;
542 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
543 case DBTYPE_I2
: hr
= VarUI4FromI2(*(signed short*)src
, d
); break;
544 case DBTYPE_I4
: hr
= VarUI4FromI4(*(signed int*)src
, d
); break;
545 case DBTYPE_R4
: hr
= VarUI4FromR4(*(FLOAT
*)src
, d
); break;
546 case DBTYPE_R8
: hr
= VarUI4FromR8(*(double*)src
, d
); break;
547 case DBTYPE_CY
: hr
= VarUI4FromCy(*(CY
*)src
, d
); break;
548 case DBTYPE_DATE
: hr
= VarUI4FromDate(*(DATE
*)src
, d
); break;
549 case DBTYPE_BSTR
: hr
= VarUI4FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
550 case DBTYPE_BOOL
: hr
= VarUI4FromBool(*(VARIANT_BOOL
*)src
, d
); break;
551 case DBTYPE_DECIMAL
: hr
= VarUI4FromDec((DECIMAL
*)src
, d
); break;
552 case DBTYPE_I1
: hr
= VarUI4FromI1(*(signed char*)src
, d
); break;
553 case DBTYPE_UI1
: hr
= VarUI4FromUI1(*(BYTE
*)src
, d
); break;
554 case DBTYPE_UI2
: hr
= VarUI4FromUI2(*(WORD
*)src
, d
); break;
555 case DBTYPE_UI4
: *d
= *(DWORD
*)src
; hr
= S_OK
; break;
556 case DBTYPE_I8
: hr
= VarUI4FromI8(*(LONGLONG
*)src
, d
); break;
557 case DBTYPE_UI8
: hr
= VarUI4FromUI8(*(ULONGLONG
*)src
, d
); break;
558 default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type
); return E_NOTIMPL
;
568 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
569 case DBTYPE_I2
: hr
= VarUI8FromI2(*(signed short*)src
, d
); break;
570 case DBTYPE_I4
: {LONGLONG s
= *(signed int*)src
; hr
= VarUI8FromI8(s
, d
); break;}
571 case DBTYPE_R4
: hr
= VarUI8FromR4(*(FLOAT
*)src
, d
); break;
572 case DBTYPE_R8
: hr
= VarUI8FromR8(*(double*)src
, d
); break;
573 case DBTYPE_CY
: hr
= VarUI8FromCy(*(CY
*)src
, d
); break;
574 case DBTYPE_DATE
: hr
= VarUI8FromDate(*(DATE
*)src
, d
); break;
575 case DBTYPE_BSTR
: hr
= VarUI8FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
576 case DBTYPE_BOOL
: hr
= VarUI8FromBool(*(VARIANT_BOOL
*)src
, d
); break;
577 case DBTYPE_DECIMAL
: hr
= VarUI8FromDec((DECIMAL
*)src
, d
); break;
578 case DBTYPE_I1
: hr
= VarUI8FromI1(*(signed char*)src
, d
); break;
579 case DBTYPE_UI1
: hr
= VarUI8FromUI1(*(BYTE
*)src
, d
); break;
580 case DBTYPE_UI2
: hr
= VarUI8FromUI2(*(WORD
*)src
, d
); break;
581 case DBTYPE_UI4
: hr
= VarUI8FromUI4(*(DWORD
*)src
, d
); break;
582 case DBTYPE_I8
: hr
= VarUI8FromI8(*(LONGLONG
*)src
, d
); break;
583 case DBTYPE_UI8
: *d
= *(ULONGLONG
*)src
; hr
= S_OK
; break;
584 default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type
); return E_NOTIMPL
;
589 case DBTYPE_FILETIME
:
594 case DBTYPE_EMPTY
: d
->dwLowDateTime
= d
->dwHighDateTime
= 0; hr
= S_OK
; break;
595 case DBTYPE_FILETIME
: *d
= *(FILETIME
*)src
; hr
= S_OK
; break;
596 default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type
); return E_NOTIMPL
;
606 case DBTYPE_EMPTY
: *d
= GUID_NULL
; hr
= S_OK
; break;
607 case DBTYPE_GUID
: *d
= *(GUID
*)src
; hr
= S_OK
; break;
608 default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type
); return E_NOTIMPL
;
618 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
619 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
620 precision
, scale
, flags
);
621 if(hr
!= S_OK
) return hr
;
622 bstr_len
= SysStringLen(b
);
623 *dst_len
= bstr_len
* sizeof(WCHAR
); /* Doesn't include size for '\0' */
624 *dst_status
= DBSTATUS_S_OK
;
625 bytes_to_copy
= min(*dst_len
+ sizeof(WCHAR
), dst_max_len
);
628 if(bytes_to_copy
>= sizeof(WCHAR
))
630 memcpy(dst
, b
, bytes_to_copy
- sizeof(WCHAR
));
631 *((WCHAR
*)dst
+ bytes_to_copy
/ sizeof(WCHAR
) - 1) = 0;
632 if(bytes_to_copy
< *dst_len
+ sizeof(WCHAR
))
633 *dst_status
= DBSTATUS_S_TRUNCATED
;
637 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
638 hr
= DB_E_ERRORSOCCURRED
;
649 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
650 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
651 precision
, scale
, flags
);
652 if(hr
!= S_OK
) return hr
;
653 bstr_len
= SysStringLen(b
);
654 *dst_len
= bstr_len
* sizeof(char); /* Doesn't include size for '\0' */
655 *dst_status
= DBSTATUS_S_OK
;
656 bytes_to_copy
= min(*dst_len
+ sizeof(char), dst_max_len
);
659 if(bytes_to_copy
>= sizeof(char))
661 WideCharToMultiByte(CP_ACP
, 0, b
, bytes_to_copy
- sizeof(char), dst
, dst_max_len
, NULL
, NULL
);
662 *((char *)dst
+ bytes_to_copy
/ sizeof(char) - 1) = 0;
663 if(bytes_to_copy
< *dst_len
+ sizeof(char))
664 *dst_status
= DBSTATUS_S_TRUNCATED
;
668 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
669 hr
= DB_E_ERRORSOCCURRED
;
676 case DBTYPE_BYREF
| DBTYPE_WSTR
:
681 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
682 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
683 precision
, scale
, flags
);
684 if(hr
!= S_OK
) return hr
;
686 bstr_len
= SysStringLen(b
) * sizeof(WCHAR
);
687 *dst_len
= bstr_len
; /* Doesn't include size for '\0' */
689 *d
= CoTaskMemAlloc(bstr_len
+ sizeof(WCHAR
));
690 if(*d
) memcpy(*d
, b
, bstr_len
+ sizeof(WCHAR
));
691 else hr
= E_OUTOFMEMORY
;
697 FIXME("Unimplemented conversion %04x -> %04x\n", src_type
, dst_type
);
702 if(hr
== DISP_E_OVERFLOW
)
704 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
705 *dst_len
= get_length(dst_type
);
706 hr
= DB_E_ERRORSOCCURRED
;
710 *dst_status
= DBSTATUS_S_OK
;
711 *dst_len
= get_length(dst_type
);
717 static inline WORD
get_dbtype_class(DBTYPE type
)
744 case DBTYPE_DBTIMESTAMP
:
745 return DBTYPE_DBDATE
;
750 /* Many src types will convert to this group of dst types */
751 static inline BOOL
common_class(WORD dst_class
)
771 static inline BOOL
array_type(DBTYPE type
)
773 return (type
>= DBTYPE_I2
&& type
<= DBTYPE_UI4
);
776 static HRESULT WINAPI
convert_CanConvert(IDataConvert
* iface
,
777 DBTYPE src_type
, DBTYPE dst_type
)
779 convert
*This
= impl_from_IDataConvert(iface
);
780 DBTYPE src_base_type
= src_type
& 0x1ff;
781 DBTYPE dst_base_type
= dst_type
& 0x1ff;
782 WORD dst_class
= get_dbtype_class(dst_base_type
);
784 TRACE("(%p)->(%d, %d)\n", This
, src_type
, dst_type
);
786 if(src_type
& DBTYPE_VECTOR
|| dst_type
& DBTYPE_VECTOR
) return S_FALSE
;
788 if(src_type
& DBTYPE_ARRAY
)
790 if(!array_type(src_base_type
)) return S_FALSE
;
791 if(dst_type
& DBTYPE_ARRAY
)
793 if(src_type
== dst_type
) return S_OK
;
796 if(dst_type
== DBTYPE_VARIANT
) return S_OK
;
800 if(dst_type
& DBTYPE_ARRAY
)
802 if(!array_type(dst_base_type
)) return S_FALSE
;
803 if(src_type
== DBTYPE_IDISPATCH
|| src_type
== DBTYPE_VARIANT
) return S_OK
;
807 if(dst_type
& DBTYPE_BYREF
)
808 if(dst_base_type
!= DBTYPE_BYTES
&& dst_base_type
!= DBTYPE_STR
&& dst_base_type
!= DBTYPE_WSTR
)
811 switch(get_dbtype_class(src_base_type
))
814 if(common_class(dst_class
)) return S_OK
;
819 case DBTYPE_FILETIME
:
822 if(dst_base_type
== DBTYPE_DBTIMESTAMP
) return S_OK
;
827 switch(dst_base_type
)
831 case DBTYPE_FILETIME
: return S_OK
;
832 default: return S_FALSE
;
836 if(dst_base_type
== DBTYPE_BYTES
) return S_OK
;
839 if(dst_base_type
== DBTYPE_DATE
) return S_OK
;
842 if(common_class(dst_class
)) return S_OK
;
843 if(dst_class
== DBTYPE_DBDATE
) return S_OK
;
847 if(dst_base_type
== DBTYPE_DATE
) return S_OK
;
850 if(common_class(dst_class
)) return S_OK
;
854 if(common_class(dst_class
)) return S_OK
;
855 switch(dst_base_type
)
858 case DBTYPE_FILETIME
: return S_OK
;
859 default: return S_FALSE
;
875 case DBTYPE_FILETIME
:
877 default: return S_FALSE
;
880 case DBTYPE_IDISPATCH
:
882 switch(dst_base_type
)
884 case DBTYPE_IDISPATCH
:
886 case DBTYPE_IUNKNOWN
:
891 if(common_class(dst_class
)) return S_OK
;
898 case DBTYPE_FILETIME
:
900 default: return S_FALSE
;
904 switch(dst_base_type
)
911 default: return S_FALSE
;
914 case DBTYPE_IUNKNOWN
:
915 switch(dst_base_type
)
919 case DBTYPE_IDISPATCH
:
921 case DBTYPE_IUNKNOWN
:
923 default: return S_FALSE
;
927 if(dst_class
== DBTYPE_I4
|| dst_class
== DBTYPE_I8
) return S_OK
;
939 default: return S_FALSE
;
942 case DBTYPE_FILETIME
:
943 if(dst_class
== DBTYPE_I8
) return S_OK
;
954 case DBTYPE_FILETIME
:
956 default: return S_FALSE
;
963 static HRESULT WINAPI
convert_GetConversionSize(IDataConvert
* iface
,
964 DBTYPE wSrcType
, DBTYPE wDstType
,
965 DBLENGTH
*pcbSrcLength
, DBLENGTH
*pcbDstLength
,
968 convert
*This
= impl_from_IDataConvert(iface
);
969 FIXME("(%p)->(%d, %d, %p, %p, %p): stub\n", This
, wSrcType
, wDstType
, pcbSrcLength
, pcbDstLength
, pSrc
);
974 static const struct IDataConvertVtbl convert_vtbl
=
976 convert_QueryInterface
,
981 convert_GetConversionSize
984 static HRESULT WINAPI
dcinfo_QueryInterface(IDCInfo
* iface
, REFIID riid
, void **obj
)
986 convert
*This
= impl_from_IDCInfo(iface
);
988 return IDataConvert_QueryInterface(&This
->IDataConvert_iface
, riid
, obj
);
991 static ULONG WINAPI
dcinfo_AddRef(IDCInfo
* iface
)
993 convert
*This
= impl_from_IDCInfo(iface
);
995 return IDataConvert_AddRef(&This
->IDataConvert_iface
);
998 static ULONG WINAPI
dcinfo_Release(IDCInfo
* iface
)
1000 convert
*This
= impl_from_IDCInfo(iface
);
1002 return IDataConvert_Release(&This
->IDataConvert_iface
);
1005 static HRESULT WINAPI
dcinfo_GetInfo(IDCInfo
*iface
, ULONG num
, DCINFOTYPE types
[], DCINFO
**info_ptr
)
1007 convert
*This
= impl_from_IDCInfo(iface
);
1011 TRACE("(%p)->(%d, %p, %p)\n", This
, num
, types
, info_ptr
);
1013 *info_ptr
= infos
= CoTaskMemAlloc(num
* sizeof(*infos
));
1014 if(!infos
) return E_OUTOFMEMORY
;
1016 for(i
= 0; i
< num
; i
++)
1018 infos
[i
].eInfoType
= types
[i
];
1019 VariantInit(&infos
[i
].vData
);
1023 case DCINFOTYPE_VERSION
:
1024 V_VT(&infos
[i
].vData
) = VT_UI4
;
1025 V_UI4(&infos
[i
].vData
) = This
->version
;
1033 static HRESULT WINAPI
dcinfo_SetInfo(IDCInfo
* iface
, ULONG num
, DCINFO info
[])
1035 convert
*This
= impl_from_IDCInfo(iface
);
1039 TRACE("(%p)->(%d, %p)\n", This
, num
, info
);
1041 for(i
= 0; i
< num
; i
++)
1043 switch(info
[i
].eInfoType
)
1045 case DCINFOTYPE_VERSION
:
1046 if(V_VT(&info
[i
].vData
) != VT_UI4
)
1048 FIXME("VERSION with vt %x\n", V_VT(&info
[i
].vData
));
1049 hr
= DB_S_ERRORSOCCURRED
;
1052 This
->version
= V_UI4(&info
[i
].vData
);
1056 FIXME("Unhandled info type %d (vt %x)\n", info
[i
].eInfoType
, V_VT(&info
[i
].vData
));
1062 static const struct IDCInfoVtbl dcinfo_vtbl
=
1064 dcinfo_QueryInterface
,
1071 HRESULT
create_oledb_convert(IUnknown
*outer
, void **obj
)
1075 TRACE("(%p, %p)\n", outer
, obj
);
1079 if(outer
) return CLASS_E_NOAGGREGATION
;
1081 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
1082 if(!This
) return E_OUTOFMEMORY
;
1084 This
->IDataConvert_iface
.lpVtbl
= &convert_vtbl
;
1085 This
->IDCInfo_iface
.lpVtbl
= &dcinfo_vtbl
;
1087 This
->version
= 0x110;
1089 *obj
= &This
->IDataConvert_iface
;