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
31 #include "oledb_private.h"
33 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(oledb
);
39 IDataConvert IDataConvert_iface
;
40 IDCInfo IDCInfo_iface
;
44 UINT version
; /* Set by IDCInfo_SetInfo */
47 static inline convert
*impl_from_IDataConvert(IDataConvert
*iface
)
49 return CONTAINING_RECORD(iface
, convert
, IDataConvert_iface
);
52 static inline convert
*impl_from_IDCInfo(IDCInfo
*iface
)
54 return CONTAINING_RECORD(iface
, convert
, IDCInfo_iface
);
57 static HRESULT WINAPI
convert_QueryInterface(IDataConvert
* iface
,
61 convert
*This
= impl_from_IDataConvert(iface
);
62 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), obj
);
66 if(IsEqualIID(riid
, &IID_IUnknown
) ||
67 IsEqualIID(riid
, &IID_IDataConvert
))
71 else if(IsEqualIID(riid
, &IID_IDCInfo
))
73 *obj
= &This
->IDCInfo_iface
;
77 FIXME("interface %s not implemented\n", debugstr_guid(riid
));
81 IDataConvert_AddRef(iface
);
86 static ULONG WINAPI
convert_AddRef(IDataConvert
* iface
)
88 convert
*This
= impl_from_IDataConvert(iface
);
89 TRACE("(%p)\n", This
);
91 return InterlockedIncrement(&This
->ref
);
95 static ULONG WINAPI
convert_Release(IDataConvert
* iface
)
97 convert
*This
= impl_from_IDataConvert(iface
);
100 TRACE("(%p)\n", This
);
102 ref
= InterlockedDecrement(&This
->ref
);
109 static int get_length(DBTYPE type
)
120 return sizeof(VARIANT_BOOL
);
131 return sizeof(DBDATE
);
132 case DBTYPE_DBTIMESTAMP
:
133 return sizeof(DBTIMESTAMP
);
138 case DBTYPE_FILETIME
:
139 return sizeof(FILETIME
);
143 return sizeof(DB_NUMERIC
);
147 case DBTYPE_BYREF
| DBTYPE_WSTR
:
150 return sizeof(VARIANT
);
152 FIXME("Unhandled type %04x\n", type
);
157 static HRESULT WINAPI
convert_DataConvert(IDataConvert
* iface
,
158 DBTYPE src_type
, DBTYPE dst_type
,
159 DBLENGTH src_len
, DBLENGTH
*dst_len
,
160 void *src
, void *dst
,
161 DBLENGTH dst_max_len
,
162 DBSTATUS src_status
, DBSTATUS
*dst_status
,
163 BYTE precision
, BYTE scale
,
166 convert
*This
= impl_from_IDataConvert(iface
);
167 DBLENGTH dst_len_loc
;
168 DBSTATUS dst_status_loc
;
172 TRACE("(%p)->(%d, %d, %Id, %p, %p, %p, %Id, %ld, %p, %d, %d, %lx)\n", This
,
173 src_type
, dst_type
, src_len
, dst_len
, src
, dst
, dst_max_len
,
174 src_status
, dst_status
, precision
, scale
, flags
);
176 if (!dst_len
) dst_len
= &dst_len_loc
;
177 if (!dst_status
) dst_status
= &dst_status_loc
;
179 *dst_status
= DBSTATUS_E_BADACCESSOR
;
181 if(src_status
== DBSTATUS_S_ISNULL
)
183 *dst_status
= DBSTATUS_S_ISNULL
;
188 if(src_type
== DBTYPE_VARIANT
&& V_VT((VARIANT
*)src
) == VT_NULL
)
190 if(dst_type
== DBTYPE_VARIANT
)
191 *dst_len
= sizeof(VARIANT
);
193 *dst_status
= DBSTATUS_S_ISNULL
;
197 if(IDataConvert_CanConvert(iface
, src_type
, dst_type
) != S_OK
)
199 return DB_E_UNSUPPORTEDCONVERSION
;
202 if(dst
== NULL
&& get_length(dst_type
) != 0)
204 *dst_len
= get_length(src_type
);
205 *dst_status
= DBSTATUS_S_OK
;
209 if(src_type
== DBTYPE_STR
)
214 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
215 len
= MultiByteToWideChar(CP_ACP
, 0, src
, -1, NULL
, 0) - 1;
217 len
= MultiByteToWideChar(CP_ACP
, 0, src
, src_len
, NULL
, 0);
218 b
= SysAllocStringLen(NULL
, len
);
219 if(!b
) return E_OUTOFMEMORY
;
220 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
221 MultiByteToWideChar(CP_ACP
, 0, src
, -1, b
, len
+ 1);
223 MultiByteToWideChar(CP_ACP
, 0, src
, src_len
, b
, len
);
225 hr
= IDataConvert_DataConvert(iface
, DBTYPE_BSTR
, dst_type
, 0, dst_len
,
226 &b
, dst
, dst_max_len
, src_status
, dst_status
,
227 precision
, scale
, flags
);
233 if(src_type
== DBTYPE_WSTR
)
237 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
238 b
= SysAllocString(src
);
240 b
= SysAllocStringLen(src
, src_len
/ 2);
241 if(!b
) return E_OUTOFMEMORY
;
242 hr
= IDataConvert_DataConvert(iface
, DBTYPE_BSTR
, dst_type
, 0, dst_len
,
243 &b
, dst
, dst_max_len
, src_status
, dst_status
,
244 precision
, scale
, flags
);
253 signed char *d
= dst
;
256 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
257 case DBTYPE_I1
: *d
= *(signed char*)src
; hr
= S_OK
; break;
258 case DBTYPE_I2
: hr
= VarI1FromI2(*(signed short*)src
, d
); break;
259 case DBTYPE_I4
: hr
= VarI1FromI4(*(signed int*)src
, d
); break;
260 case DBTYPE_R4
: hr
= VarI1FromR4(*(FLOAT
*)src
, d
); break;
261 case DBTYPE_R8
: hr
= VarI1FromR8(*(double*)src
, d
); break;
262 case DBTYPE_CY
: hr
= VarI1FromCy(*(CY
*)src
, d
); break;
263 case DBTYPE_DATE
: hr
= VarI1FromDate(*(DATE
*)src
, d
); break;
264 case DBTYPE_BSTR
: hr
= VarI1FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
265 case DBTYPE_BOOL
: hr
= VarI1FromBool(*(VARIANT_BOOL
*)src
, d
); break;
266 case DBTYPE_DECIMAL
: hr
= VarI1FromDec(src
, d
); break;
267 case DBTYPE_UI1
: hr
= VarI1FromUI1(*(BYTE
*)src
, d
); break;
268 case DBTYPE_UI2
: hr
= VarI1FromUI2(*(WORD
*)src
, d
); break;
269 case DBTYPE_UI4
: hr
= VarI1FromUI4(*(DWORD
*)src
, d
); break;
270 case DBTYPE_I8
: hr
= VarI1FromI8(*(LONGLONG
*)src
, d
); break;
271 case DBTYPE_UI8
: hr
= VarI1FromUI8(*(ULONGLONG
*)src
, d
); break;
274 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_I1
)) == S_OK
)
277 default: FIXME("Unimplemented conversion %04x -> I1\n", src_type
); return E_NOTIMPL
;
284 signed short *d
= dst
;
287 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
288 case DBTYPE_I2
: *d
= *(signed short*)src
; hr
= S_OK
; break;
289 case DBTYPE_I4
: hr
= VarI2FromI4(*(signed int*)src
, d
); break;
290 case DBTYPE_R4
: hr
= VarI2FromR4(*(FLOAT
*)src
, d
); break;
291 case DBTYPE_R8
: hr
= VarI2FromR8(*(double*)src
, d
); break;
292 case DBTYPE_CY
: hr
= VarI2FromCy(*(CY
*)src
, d
); break;
293 case DBTYPE_DATE
: hr
= VarI2FromDate(*(DATE
*)src
, d
); break;
294 case DBTYPE_BSTR
: hr
= VarI2FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
295 case DBTYPE_BOOL
: hr
= VarI2FromBool(*(VARIANT_BOOL
*)src
, d
); break;
296 case DBTYPE_DECIMAL
: hr
= VarI2FromDec(src
, d
); break;
297 case DBTYPE_I1
: hr
= VarI2FromI1(*(signed char*)src
, d
); break;
298 case DBTYPE_UI1
: hr
= VarI2FromUI1(*(BYTE
*)src
, d
); break;
299 case DBTYPE_UI2
: hr
= VarI2FromUI2(*(WORD
*)src
, d
); break;
300 case DBTYPE_UI4
: hr
= VarI2FromUI4(*(DWORD
*)src
, d
); break;
301 case DBTYPE_I8
: hr
= VarI2FromI8(*(LONGLONG
*)src
, d
); break;
302 case DBTYPE_UI8
: hr
= VarI2FromUI8(*(ULONGLONG
*)src
, d
); break;
305 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_I2
)) == S_OK
)
308 default: FIXME("Unimplemented conversion %04x -> I2\n", src_type
); return E_NOTIMPL
;
318 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
319 case DBTYPE_I2
: hr
= VarI4FromI2(*(signed short*)src
, d
); break;
320 case DBTYPE_I4
: *d
= *(signed int*)src
; hr
= S_OK
; break;
321 case DBTYPE_R4
: hr
= VarI4FromR4(*(FLOAT
*)src
, d
); break;
322 case DBTYPE_R8
: hr
= VarI4FromR8(*(double*)src
, d
); break;
323 case DBTYPE_CY
: hr
= VarI4FromCy(*(CY
*)src
, d
); break;
324 case DBTYPE_DATE
: hr
= VarI4FromDate(*(DATE
*)src
, d
); break;
325 case DBTYPE_BSTR
: hr
= VarI4FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
326 case DBTYPE_BOOL
: hr
= VarI4FromBool(*(VARIANT_BOOL
*)src
, d
); break;
327 case DBTYPE_DECIMAL
: hr
= VarI4FromDec(src
, d
); break;
328 case DBTYPE_I1
: hr
= VarI4FromI1(*(signed char*)src
, d
); break;
329 case DBTYPE_UI1
: hr
= VarI4FromUI1(*(BYTE
*)src
, d
); break;
330 case DBTYPE_UI2
: hr
= VarI4FromUI2(*(WORD
*)src
, d
); break;
331 case DBTYPE_UI4
: hr
= VarI4FromUI4(*(DWORD
*)src
, d
); break;
332 case DBTYPE_I8
: hr
= VarI4FromI8(*(LONGLONG
*)src
, d
); break;
333 case DBTYPE_UI8
: hr
= VarI4FromUI8(*(ULONGLONG
*)src
, d
); break;
336 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_I4
)) == S_OK
)
339 default: FIXME("Unimplemented conversion %04x -> I4\n", src_type
); return E_NOTIMPL
;
349 case DBTYPE_BSTR
: hr
= VarI8FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
350 case DBTYPE_I8
: *d
= *(LONGLONG
*)src
; hr
= S_OK
; break;
351 default: FIXME("Unimplemented conversion %04x -> I8\n", src_type
); return E_NOTIMPL
;
361 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
362 case DBTYPE_I2
: hr
= VarR4FromI2(*(signed short*)src
, d
); break;
363 case DBTYPE_I4
: hr
= VarR4FromI4(*(signed int*)src
, d
); break;
364 case DBTYPE_R4
: *d
= *(FLOAT
*)src
; hr
= S_OK
; break;
365 case DBTYPE_R8
: hr
= VarR4FromR8(*(double*)src
, d
); break;
366 case DBTYPE_CY
: hr
= VarR4FromCy(*(CY
*)src
, d
); break;
367 case DBTYPE_DATE
: hr
= VarR4FromDate(*(DATE
*)src
, d
); break;
368 case DBTYPE_BSTR
: hr
= VarR4FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
369 case DBTYPE_BOOL
: hr
= VarR4FromBool(*(VARIANT_BOOL
*)src
, d
); break;
370 case DBTYPE_DECIMAL
: hr
= VarR4FromDec(src
, d
); break;
371 case DBTYPE_I1
: hr
= VarR4FromI1(*(signed char*)src
, d
); break;
372 case DBTYPE_UI1
: hr
= VarR4FromUI1(*(BYTE
*)src
, d
); break;
373 case DBTYPE_UI2
: hr
= VarR4FromUI2(*(WORD
*)src
, d
); break;
374 case DBTYPE_UI4
: hr
= VarR4FromUI4(*(DWORD
*)src
, d
); break;
375 case DBTYPE_I8
: hr
= VarR4FromI8(*(LONGLONG
*)src
, d
); break;
376 case DBTYPE_UI8
: hr
= VarR4FromUI8(*(ULONGLONG
*)src
, d
); break;
379 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_R4
)) == S_OK
)
382 default: FIXME("Unimplemented conversion %04x -> R4\n", src_type
); return E_NOTIMPL
;
391 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
392 case DBTYPE_I1
: hr
= VarR8FromI1(*(signed char*)src
, d
); break;
393 case DBTYPE_I2
: hr
= VarR8FromI2(*(signed short*)src
, d
); break;
394 case DBTYPE_I4
: hr
= VarR8FromI4(*(signed int*)src
, d
); break;
395 case DBTYPE_I8
: hr
= VarR8FromI8(*(LONGLONG
*)src
, d
); break;
396 case DBTYPE_UI1
: hr
= VarR8FromUI1(*(BYTE
*)src
, d
); break;
397 case DBTYPE_UI2
: hr
= VarR8FromUI2(*(WORD
*)src
, d
); break;
398 case DBTYPE_UI4
: hr
= VarR8FromUI4(*(DWORD
*)src
, d
); break;
399 case DBTYPE_UI8
: hr
= VarR8FromUI8(*(ULONGLONG
*)src
, d
); break;
400 case DBTYPE_R4
: hr
= VarR8FromR4(*(FLOAT
*)src
, d
); break;
401 case DBTYPE_R8
: *d
= *(DOUBLE
*)src
; hr
= S_OK
; break;
402 case DBTYPE_CY
: hr
= VarR8FromCy(*(CY
*)src
, d
); break;
403 case DBTYPE_DATE
: hr
= VarR8FromDate(*(DATE
*)src
, d
); break;
404 case DBTYPE_BSTR
: hr
= VarR8FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
405 case DBTYPE_BOOL
: hr
= VarR8FromBool(*(VARIANT_BOOL
*)src
, d
); break;
406 case DBTYPE_DECIMAL
: hr
= VarR8FromDec(src
, d
); break;
409 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_R8
)) == S_OK
)
412 default: FIXME("Unimplemented conversion %04x -> R8\n", src_type
); return E_NOTIMPL
;
421 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
422 case DBTYPE_I1
: hr
= VarBoolFromI1(*(signed char*)src
, d
); break;
423 case DBTYPE_I2
: hr
= VarBoolFromI2(*(signed short*)src
, d
); break;
424 case DBTYPE_I4
: hr
= VarBoolFromI4(*(signed int*)src
, d
); break;
425 case DBTYPE_I8
: hr
= VarBoolFromI8(*(LONGLONG
*)src
, d
); break;
426 case DBTYPE_UI1
: hr
= VarBoolFromUI1(*(BYTE
*)src
, d
); break;
427 case DBTYPE_UI2
: hr
= VarBoolFromUI2(*(WORD
*)src
, d
); break;
428 case DBTYPE_UI4
: hr
= VarBoolFromUI4(*(DWORD
*)src
, d
); break;
429 case DBTYPE_UI8
: hr
= VarBoolFromUI8(*(ULONGLONG
*)src
, d
); break;
430 case DBTYPE_R4
: hr
= VarBoolFromR4(*(FLOAT
*)src
, d
); break;
431 case DBTYPE_R8
: hr
= VarBoolFromR8(*(DOUBLE
*)src
, d
); break;
432 case DBTYPE_CY
: hr
= VarBoolFromCy(*(CY
*)src
, d
); break;
433 case DBTYPE_DATE
: hr
= VarBoolFromDate(*(DATE
*)src
, d
); break;
434 case DBTYPE_BSTR
: hr
= VarBoolFromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
435 case DBTYPE_BOOL
: *d
= *(VARIANT_BOOL
*)src
; hr
= S_OK
; break;
436 case DBTYPE_DECIMAL
: hr
= VarBoolFromDec(src
, d
); break;
437 default: FIXME("Unimplemented conversion %04x -> BOOL\n", src_type
); return E_NOTIMPL
;
446 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
447 case DBTYPE_I1
: hr
= VarDateFromI1(*(signed char*)src
, d
); break;
448 case DBTYPE_I2
: hr
= VarDateFromI2(*(signed short*)src
, d
); break;
449 case DBTYPE_I4
: hr
= VarDateFromI4(*(signed int*)src
, d
); break;
450 case DBTYPE_I8
: hr
= VarDateFromI8(*(LONGLONG
*)src
, d
); break;
451 case DBTYPE_UI1
: hr
= VarDateFromUI1(*(BYTE
*)src
, d
); break;
452 case DBTYPE_UI2
: hr
= VarDateFromUI2(*(WORD
*)src
, d
); break;
453 case DBTYPE_UI4
: hr
= VarDateFromUI4(*(DWORD
*)src
, d
); break;
454 case DBTYPE_UI8
: hr
= VarDateFromUI8(*(ULONGLONG
*)src
, d
); break;
455 case DBTYPE_R4
: hr
= VarDateFromR4(*(FLOAT
*)src
, d
); break;
456 case DBTYPE_R8
: hr
= VarDateFromR8(*(DOUBLE
*)src
, d
); break;
457 case DBTYPE_CY
: hr
= VarDateFromCy(*(CY
*)src
, d
); break;
458 case DBTYPE_DATE
: *d
= *(DATE
*)src
; hr
= S_OK
; break;
459 case DBTYPE_BSTR
: hr
= VarDateFromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
460 case DBTYPE_BOOL
: hr
= VarDateFromBool(*(VARIANT_BOOL
*)src
, d
); break;
461 case DBTYPE_DECIMAL
: hr
= VarDateFromDec(src
, d
); break;
462 case DBTYPE_DBTIMESTAMP
:
465 DBTIMESTAMP
*ts
= src
;
468 st
.wMonth
= ts
->month
;
471 st
.wMinute
= ts
->minute
;
472 st
.wSecond
= ts
->second
;
473 st
.wMilliseconds
= ts
->fraction
/1000000;
474 hr
= (SystemTimeToVariantTime(&st
, d
) ? S_OK
: E_FAIL
);
481 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_DATE
)) == S_OK
)
485 default: FIXME("Unimplemented conversion %04x -> DATE\n", src_type
); return E_NOTIMPL
;
494 case DBTYPE_DBDATE
: memcpy(d
, src
, sizeof(DBDATE
)); hr
= S_OK
; break;
498 BSTR s
= *(WCHAR
**)src
;
501 V_VT(&var
) = VT_BSTR
;
502 V_BSTR(&var
) = SysAllocString(s
);
504 if ((hr
= VariantChangeType(&var
, &var
, 0, VT_DATE
)) == S_OK
)
507 hr
= (VariantTimeToSystemTime( V_DATE(&var
), &st
) ? S_OK
: E_FAIL
);
509 d
->month
= st
.wMonth
;
520 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_DATE
)) == S_OK
)
523 hr
= (VariantTimeToSystemTime( V_DATE(&tmp
), &st
) ? S_OK
: E_FAIL
);
525 d
->month
= st
.wMonth
;
530 FIXME("Unimplemented variant type %d -> DBDATE\n", V_VT((VARIANT
*)src
));
535 default: FIXME("Unimplemented conversion %04x -> DBDATE\n", src_type
); return E_NOTIMPL
;
539 case DBTYPE_DBTIMESTAMP
:
544 case DBTYPE_EMPTY
: memset(d
, 0, sizeof(DBTIMESTAMP
)); hr
= S_OK
; break;
545 case DBTYPE_DBTIMESTAMP
: memcpy(d
, src
, sizeof(DBTIMESTAMP
)); hr
= S_OK
; break;
549 BSTR s
= *(WCHAR
**)src
;
552 V_VT(&var
) = VT_BSTR
;
553 V_BSTR(&var
) = SysAllocString(s
);
555 if ((hr
= VariantChangeType(&var
, &var
, 0, VT_DATE
)) == S_OK
)
559 hr
= (VariantTimeToSystemTime( V_DATE(&var
), &st
) ? S_OK
: E_FAIL
);
561 d
->month
= st
.wMonth
;
564 d
->minute
= st
.wMinute
;
565 d
->second
= st
.wSecond
;
566 d
->fraction
= st
.wMilliseconds
* 1000000;
570 if(swscanf( s
, L
"%d-%d-%d %d:%d:%d.%d", &d
->year
, &d
->month
, &d
->day
, &d
->hour
, &d
->minute
,
571 &d
->second
, &d
->fraction
) != 7)
573 hr
= DISP_E_TYPEMISMATCH
;
574 *dst_status
= DBSTATUS_E_CANTCONVERTVALUE
;
575 *dst_len
= get_length(dst_type
);
587 hr
= (VariantTimeToSystemTime(*(double*)src
, &st
) ? S_OK
: E_FAIL
);
589 d
->month
= st
.wMonth
;
592 d
->minute
= st
.wMinute
;
593 d
->second
= st
.wSecond
;
594 d
->fraction
= st
.wMilliseconds
* 1000000;
598 if( V_VT((VARIANT
*)src
) == VT_DATE
)
601 hr
= (VariantTimeToSystemTime( V_DATE((VARIANT
*)src
), &st
) ? S_OK
: E_FAIL
);
603 d
->month
= st
.wMonth
;
606 d
->minute
= st
.wMinute
;
607 d
->second
= st
.wSecond
;
608 d
->fraction
= st
.wMilliseconds
* 1000000;
612 FIXME("Unimplemented variant type %d -> DBTIMESTAMP\n", V_VT((VARIANT
*)src
));
616 default: FIXME("Unimplemented conversion %04x -> DBTIMESTAMP\n", src_type
); return E_NOTIMPL
;
626 case DBTYPE_EMPTY
: d
->int64
= 0; hr
= S_OK
; break;
627 case DBTYPE_I2
: hr
= VarCyFromI2(*(signed short*)src
, d
); break;
628 case DBTYPE_I4
: hr
= VarCyFromI4(*(signed int*)src
, d
); break;
629 case DBTYPE_R4
: hr
= VarCyFromR4(*(FLOAT
*)src
, d
); break;
630 case DBTYPE_R8
: hr
= VarCyFromR8(*(double*)src
, d
); break;
631 case DBTYPE_CY
: *d
= *(CY
*)src
; hr
= S_OK
; break;
632 case DBTYPE_DATE
: hr
= VarCyFromDate(*(DATE
*)src
, d
); break;
633 case DBTYPE_BSTR
: hr
= VarCyFromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
634 case DBTYPE_BOOL
: hr
= VarCyFromBool(*(VARIANT_BOOL
*)src
, d
); break;
635 case DBTYPE_DECIMAL
: hr
= VarCyFromDec(src
, d
); break;
636 case DBTYPE_I1
: hr
= VarCyFromI1(*(signed char*)src
, d
); break;
637 case DBTYPE_UI1
: hr
= VarCyFromUI1(*(BYTE
*)src
, d
); break;
638 case DBTYPE_UI2
: hr
= VarCyFromUI2(*(WORD
*)src
, d
); break;
639 case DBTYPE_UI4
: hr
= VarCyFromUI4(*(DWORD
*)src
, d
); break;
640 case DBTYPE_I8
: hr
= VarCyFromI8(*(LONGLONG
*)src
, d
); break;
641 case DBTYPE_UI8
: hr
= VarCyFromUI8(*(ULONGLONG
*)src
, d
); break;
642 default: FIXME("Unimplemented conversion %04x -> CY\n", src_type
); return E_NOTIMPL
;
652 case DBTYPE_EMPTY
: *d
= SysAllocStringLen(NULL
, 0); hr
= *d
? S_OK
: E_OUTOFMEMORY
; break;
653 case DBTYPE_I2
: hr
= VarBstrFromI2(*(signed short*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
654 case DBTYPE_I4
: hr
= VarBstrFromI4(*(signed int*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
655 case DBTYPE_R4
: hr
= VarBstrFromR4(*(FLOAT
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
656 case DBTYPE_R8
: hr
= VarBstrFromR8(*(double*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
657 case DBTYPE_CY
: hr
= VarBstrFromCy(*(CY
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
658 case DBTYPE_DATE
: hr
= VarBstrFromDate(*(DATE
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
659 case DBTYPE_BSTR
: *d
= SysAllocStringLen(*(BSTR
*)src
, SysStringLen(*(BSTR
*)src
)); hr
= *d
? S_OK
: E_OUTOFMEMORY
; break;
660 case DBTYPE_BOOL
: hr
= VarBstrFromBool(*(VARIANT_BOOL
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
661 case DBTYPE_DECIMAL
: hr
= VarBstrFromDec(src
, LOCALE_USER_DEFAULT
, 0, d
); break;
662 case DBTYPE_I1
: hr
= VarBstrFromI1(*(signed char*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
663 case DBTYPE_UI1
: hr
= VarBstrFromUI1(*(BYTE
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
664 case DBTYPE_UI2
: hr
= VarBstrFromUI2(*(WORD
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
665 case DBTYPE_UI4
: hr
= VarBstrFromUI4(*(DWORD
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
666 case DBTYPE_I8
: hr
= VarBstrFromI8(*(LONGLONG
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
667 case DBTYPE_UI8
: hr
= VarBstrFromUI8(*(ULONGLONG
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
671 const GUID
*id
= src
;
672 wsprintfW(szBuff
, L
"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
673 id
->Data1
, id
->Data2
, id
->Data3
,
674 id
->Data4
[0], id
->Data4
[1], id
->Data4
[2], id
->Data4
[3],
675 id
->Data4
[4], id
->Data4
[5], id
->Data4
[6], id
->Data4
[7] );
676 *d
= SysAllocString(szBuff
);
677 hr
= *d
? S_OK
: E_OUTOFMEMORY
;
682 *d
= SysAllocStringLen(NULL
, 2 * src_len
);
687 static const char hexchars
[] = "0123456789ABCDEF";
689 unsigned char *p
= src
;
692 *s
++ = hexchars
[(*p
>> 4) & 0x0F];
693 *s
++ = hexchars
[(*p
) & 0x0F];
700 case DBTYPE_DBTIMESTAMP
:
703 DBTIMESTAMP
*ts
= src
;
705 if(ts
->fraction
== 0)
706 wsprintfW(szBuff
, L
"%04d-%02d-%02d %02d:%02d:%02d", ts
->year
, ts
->month
, ts
->day
, ts
->hour
,
707 ts
->minute
, ts
->second
);
709 wsprintfW(szBuff
, L
"%04d-%02d-%02d %02d:%02d:%02d.%09d", ts
->year
, ts
->month
, ts
->day
, ts
->hour
,
710 ts
->minute
, ts
->second
, ts
->fraction
);
711 *d
= SysAllocString(szBuff
);
712 hr
= *d
? S_OK
: E_OUTOFMEMORY
;
717 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_BSTR
)) == S_OK
)
720 default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type
); return E_NOTIMPL
;
730 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
731 case DBTYPE_I2
: hr
= VarUI1FromI2(*(signed short*)src
, d
); break;
732 case DBTYPE_I4
: hr
= VarUI1FromI4(*(signed int*)src
, d
); break;
733 case DBTYPE_R4
: hr
= VarUI1FromR4(*(FLOAT
*)src
, d
); break;
734 case DBTYPE_R8
: hr
= VarUI1FromR8(*(double*)src
, d
); break;
735 case DBTYPE_CY
: hr
= VarUI1FromCy(*(CY
*)src
, d
); break;
736 case DBTYPE_DATE
: hr
= VarUI1FromDate(*(DATE
*)src
, d
); break;
737 case DBTYPE_BSTR
: hr
= VarUI1FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
738 case DBTYPE_BOOL
: hr
= VarUI1FromBool(*(VARIANT_BOOL
*)src
, d
); break;
739 case DBTYPE_DECIMAL
: hr
= VarUI1FromDec(src
, d
); break;
740 case DBTYPE_I1
: hr
= VarUI1FromI1(*(signed char*)src
, d
); break;
741 case DBTYPE_UI1
: *d
= *(BYTE
*)src
; hr
= S_OK
; break;
742 case DBTYPE_UI2
: hr
= VarUI1FromUI2(*(WORD
*)src
, d
); break;
743 case DBTYPE_UI4
: hr
= VarUI1FromUI4(*(DWORD
*)src
, d
); break;
744 case DBTYPE_I8
: hr
= VarUI1FromI8(*(LONGLONG
*)src
, d
); break;
745 case DBTYPE_UI8
: hr
= VarUI1FromUI8(*(ULONGLONG
*)src
, d
); break;
746 default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type
); return E_NOTIMPL
;
755 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
756 case DBTYPE_I2
: hr
= VarUI2FromI2(*(signed short*)src
, d
); break;
757 case DBTYPE_I4
: hr
= VarUI2FromI4(*(signed int*)src
, d
); break;
758 case DBTYPE_R4
: hr
= VarUI2FromR4(*(FLOAT
*)src
, d
); break;
759 case DBTYPE_R8
: hr
= VarUI2FromR8(*(double*)src
, d
); break;
760 case DBTYPE_CY
: hr
= VarUI2FromCy(*(CY
*)src
, d
); break;
761 case DBTYPE_DATE
: hr
= VarUI2FromDate(*(DATE
*)src
, d
); break;
762 case DBTYPE_BSTR
: hr
= VarUI2FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
763 case DBTYPE_BOOL
: hr
= VarUI2FromBool(*(VARIANT_BOOL
*)src
, d
); break;
764 case DBTYPE_DECIMAL
: hr
= VarUI2FromDec(src
, d
); break;
765 case DBTYPE_I1
: hr
= VarUI2FromI1(*(signed char*)src
, d
); break;
766 case DBTYPE_UI1
: hr
= VarUI2FromUI1(*(BYTE
*)src
, d
); break;
767 case DBTYPE_UI2
: *d
= *(WORD
*)src
; hr
= S_OK
; break;
768 case DBTYPE_UI4
: hr
= VarUI2FromUI4(*(DWORD
*)src
, d
); break;
769 case DBTYPE_I8
: hr
= VarUI2FromI8(*(LONGLONG
*)src
, d
); break;
770 case DBTYPE_UI8
: hr
= VarUI2FromUI8(*(ULONGLONG
*)src
, d
); break;
771 default: FIXME("Unimplemented conversion %04x -> UI2\n", src_type
); return E_NOTIMPL
;
781 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
782 case DBTYPE_I2
: hr
= VarUI4FromI2(*(signed short*)src
, d
); break;
783 case DBTYPE_I4
: hr
= VarUI4FromI4(*(signed int*)src
, d
); break;
784 case DBTYPE_R4
: hr
= VarUI4FromR4(*(FLOAT
*)src
, d
); break;
785 case DBTYPE_R8
: hr
= VarUI4FromR8(*(double*)src
, d
); break;
786 case DBTYPE_CY
: hr
= VarUI4FromCy(*(CY
*)src
, d
); break;
787 case DBTYPE_DATE
: hr
= VarUI4FromDate(*(DATE
*)src
, d
); break;
788 case DBTYPE_BSTR
: hr
= VarUI4FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
789 case DBTYPE_BOOL
: hr
= VarUI4FromBool(*(VARIANT_BOOL
*)src
, d
); break;
790 case DBTYPE_DECIMAL
: hr
= VarUI4FromDec(src
, d
); break;
791 case DBTYPE_I1
: hr
= VarUI4FromI1(*(signed char*)src
, d
); break;
792 case DBTYPE_UI1
: hr
= VarUI4FromUI1(*(BYTE
*)src
, d
); break;
793 case DBTYPE_UI2
: hr
= VarUI4FromUI2(*(WORD
*)src
, d
); break;
794 case DBTYPE_UI4
: *d
= *(DWORD
*)src
; hr
= S_OK
; break;
795 case DBTYPE_I8
: hr
= VarUI4FromI8(*(LONGLONG
*)src
, d
); break;
796 case DBTYPE_UI8
: hr
= VarUI4FromUI8(*(ULONGLONG
*)src
, d
); break;
799 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_UI4
)) == S_OK
)
802 default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type
); return E_NOTIMPL
;
812 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
813 case DBTYPE_I2
: hr
= VarUI8FromI2(*(signed short*)src
, d
); break;
814 case DBTYPE_I4
: {LONGLONG s
= *(signed int*)src
; hr
= VarUI8FromI8(s
, d
); break;}
815 case DBTYPE_R4
: hr
= VarUI8FromR4(*(FLOAT
*)src
, d
); break;
816 case DBTYPE_R8
: hr
= VarUI8FromR8(*(double*)src
, d
); break;
817 case DBTYPE_CY
: hr
= VarUI8FromCy(*(CY
*)src
, d
); break;
818 case DBTYPE_DATE
: hr
= VarUI8FromDate(*(DATE
*)src
, d
); break;
819 case DBTYPE_BSTR
: hr
= VarUI8FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
820 case DBTYPE_BOOL
: hr
= VarUI8FromBool(*(VARIANT_BOOL
*)src
, d
); break;
821 case DBTYPE_DECIMAL
: hr
= VarUI8FromDec(src
, d
); break;
822 case DBTYPE_I1
: hr
= VarUI8FromI1(*(signed char*)src
, d
); break;
823 case DBTYPE_UI1
: hr
= VarUI8FromUI1(*(BYTE
*)src
, d
); break;
824 case DBTYPE_UI2
: hr
= VarUI8FromUI2(*(WORD
*)src
, d
); break;
825 case DBTYPE_UI4
: hr
= VarUI8FromUI4(*(DWORD
*)src
, d
); break;
826 case DBTYPE_I8
: hr
= VarUI8FromI8(*(LONGLONG
*)src
, d
); break;
827 case DBTYPE_UI8
: *d
= *(ULONGLONG
*)src
; hr
= S_OK
; break;
830 if ((hr
= VariantChangeType(&tmp
, src
, 0, VT_UI8
)) == S_OK
)
833 default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type
); return E_NOTIMPL
;
838 case DBTYPE_FILETIME
:
843 case DBTYPE_EMPTY
: d
->dwLowDateTime
= d
->dwHighDateTime
= 0; hr
= S_OK
; break;
844 case DBTYPE_FILETIME
: *d
= *(FILETIME
*)src
; hr
= S_OK
; break;
845 default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type
); return E_NOTIMPL
;
855 case DBTYPE_EMPTY
: *d
= GUID_NULL
; hr
= S_OK
; break;
856 case DBTYPE_GUID
: *d
= *(GUID
*)src
; hr
= S_OK
; break;
858 if (V_VT((VARIANT
*)src
) == VT_BSTR
)
860 hr
= CLSIDFromString(V_BSTR((VARIANT
*)src
), d
);
863 *dst_len
= sizeof(GUID
);
864 *dst_status
= DBSTATUS_E_CANTCONVERTVALUE
;
868 default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type
); return E_NOTIMPL
;
878 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
879 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
880 precision
, scale
, flags
);
881 if(hr
!= S_OK
|| *dst_status
== DBSTATUS_S_ISNULL
)
883 bstr_len
= SysStringLen(b
);
884 *dst_len
= bstr_len
* sizeof(WCHAR
); /* Doesn't include size for '\0' */
885 *dst_status
= DBSTATUS_S_OK
;
886 bytes_to_copy
= min(*dst_len
+ sizeof(WCHAR
), dst_max_len
);
889 if(bytes_to_copy
>= sizeof(WCHAR
))
891 memcpy(dst
, b
, bytes_to_copy
- sizeof(WCHAR
));
892 *((WCHAR
*)dst
+ bytes_to_copy
/ sizeof(WCHAR
) - 1) = 0;
893 if(bytes_to_copy
< *dst_len
+ sizeof(WCHAR
))
894 *dst_status
= DBSTATUS_S_TRUNCATED
;
898 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
899 hr
= DB_E_ERRORSOCCURRED
;
911 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &length
,
912 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
913 precision
, scale
, flags
);
914 if(hr
!= S_OK
) return hr
;
915 length
= WideCharToMultiByte(CP_ACP
, 0, b
, SysStringLen(b
), NULL
, 0, NULL
, NULL
);
916 *dst_len
= length
; /* Doesn't include size for '\0' */
917 *dst_status
= DBSTATUS_S_OK
;
918 bytes_to_copy
= min(length
+ 1, dst_max_len
);
921 if(bytes_to_copy
>= sizeof(char))
923 WideCharToMultiByte(CP_ACP
, 0, b
, SysStringLen(b
), dst
, bytes_to_copy
- 1, NULL
, NULL
);
924 *((char *)dst
+ bytes_to_copy
- 1) = 0;
925 if(bytes_to_copy
< length
+ 1)
926 *dst_status
= DBSTATUS_S_TRUNCATED
;
930 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
931 hr
= DB_E_ERRORSOCCURRED
;
938 case DBTYPE_BYREF
| DBTYPE_WSTR
:
943 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
944 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
945 precision
, scale
, flags
);
946 if(hr
!= S_OK
) return hr
;
948 bstr_len
= SysStringLen(b
) * sizeof(WCHAR
);
949 *dst_len
= bstr_len
; /* Doesn't include size for '\0' */
951 *d
= CoTaskMemAlloc(bstr_len
+ sizeof(WCHAR
));
952 if(*d
) memcpy(*d
, b
, bstr_len
+ sizeof(WCHAR
));
953 else hr
= E_OUTOFMEMORY
;
958 case DBTYPE_BYREF
| DBTYPE_STR
:
963 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &length
,
964 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
965 precision
, scale
, flags
);
966 if(hr
!= S_OK
) return hr
;
968 length
= WideCharToMultiByte(CP_ACP
, 0, b
, SysStringLen(b
) + 1, NULL
, 0, NULL
, NULL
);
969 *dst_len
= length
- 1; /* Doesn't include size for '\0' */
970 *dst_status
= DBSTATUS_S_OK
;
971 *d
= CoTaskMemAlloc(length
);
974 WideCharToMultiByte(CP_ACP
, 0, b
, SysStringLen(b
) + 1, *d
, length
, NULL
, NULL
);
990 V_BOOL(v
) = *(VARIANT_BOOL
*)src
;
995 V_I2(v
) = *(signed short*)src
;
1000 V_I4(v
) = *(signed int*)src
;
1004 V_VT(v
) = VT_DECIMAL
;
1005 hr
= VarDecFromI8( *(LONGLONG
*)src
, &V_DECIMAL(v
));
1009 V_R4(v
) = *(FLOAT
*)src
;
1014 V_R8(v
) = *(double*)src
;
1019 BSTR s
= *(WCHAR
**)src
;
1020 TRACE("%s\n", debugstr_w(s
));
1022 V_BSTR(v
) = SysAllocString(s
);
1023 hr
= V_BSTR(v
) ? S_OK
: E_OUTOFMEMORY
;
1028 V_DATE(v
) = *(DATE
*)src
;
1038 st
.wYear
= ts
->year
;
1039 st
.wMonth
= ts
->month
;
1044 st
.wMilliseconds
= 0;
1045 hr
= (SystemTimeToVariantTime(&st
, &V_DATE(v
)) ? S_OK
: E_FAIL
);
1048 case DBTYPE_DBTIMESTAMP
:
1051 DBTIMESTAMP
*ts
= src
;
1055 st
.wYear
= ts
->year
;
1056 st
.wMonth
= ts
->month
;
1058 st
.wHour
= ts
->hour
;
1059 st
.wMinute
= ts
->minute
;
1060 st
.wSecond
= ts
->second
;
1061 st
.wMilliseconds
= ts
->fraction
/1000000;
1062 hr
= SystemTimeToVariantTime(&st
, &V_DATE(v
)) ? S_OK
: E_FAIL
;
1067 V_CY(v
) = *(CY
*)src
;
1073 SAFEARRAY
*psa
= NULL
;
1074 SAFEARRAYBOUND rgsabound
[1];
1075 unsigned char *p
= src
;
1077 rgsabound
[0].lLbound
= 0;
1078 rgsabound
[0].cElements
= src_len
;
1080 psa
= SafeArrayCreate(VT_UI1
,1,rgsabound
);
1081 for(i
=0; i
< src_len
; i
++,p
++)
1083 hr
= SafeArrayPutElement(psa
, &i
, p
);
1085 SafeArrayDestroy (psa
);
1090 V_VT(v
) = VT_ARRAY
|VT_UI1
;
1095 case DBTYPE_VARIANT
:
1098 hr
= VariantCopy(v
, (VARIANT
*)src
);
1101 default: FIXME("Unimplemented conversion %04x -> VARIANT\n", src_type
); return E_NOTIMPL
;
1112 if( src_len
> dst_max_len
)
1113 *dst_status
= DBSTATUS_S_TRUNCATED
;
1115 *dst_status
= DBSTATUS_S_OK
;
1118 memcpy(d
, src
, min(src_len
, dst_max_len
));
1121 case DBTYPE_VARIANT
:
1123 switch(V_VT((VARIANT
*)src
))
1125 case VT_UI1
| VT_ARRAY
:
1130 hr
= SafeArrayGetUBound(V_ARRAY((VARIANT
*)src
), 1, &l
);
1134 hr
= SafeArrayAccessData(V_ARRAY((VARIANT
*)src
), (VOID
**)&data
);
1137 ERR("SafeArrayAccessData Failed = 0x%08lx\n", hr
);
1142 *dst_status
= DBSTATUS_S_OK
;
1143 memcpy(d
, data
, *dst_len
);
1145 SafeArrayUnaccessData(V_ARRAY((VARIANT
*)src
));
1150 FIXME("Unimplemented variant type %d -> BYTES\n", V_VT((VARIANT
*)src
));
1155 default: FIXME("Unimplemented conversion %04x -> DBTYPE_BYTES\n", src_type
); return E_NOTIMPL
;
1159 case DBTYPE_BYTES
| DBTYPE_BYREF
:
1166 *d
= CoTaskMemAlloc(src_len
);
1167 if(*d
) memcpy(*d
, src
, src_len
);
1168 else hr
= E_OUTOFMEMORY
;
1171 *dst_status
= DBSTATUS_S_OK
;
1173 default: FIXME("Unimplemented conversion %04x -> DBTYPE_BYTES | DBTYPE_BYREF\n", src_type
); return E_NOTIMPL
;
1178 case DBTYPE_NUMERIC
:
1179 FIXME("Unimplemented conversion %04x -> DBTYPE_NUMERIC\n", src_type
);
1183 FIXME("Unimplemented conversion %04x -> %04x\n", src_type
, dst_type
);
1187 if(hr
== DISP_E_OVERFLOW
)
1189 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
1190 *dst_len
= get_length(dst_type
);
1191 hr
= DB_E_ERRORSOCCURRED
;
1195 *dst_status
= DBSTATUS_S_OK
;
1196 *dst_len
= get_length(dst_type
);
1202 static inline WORD
get_dbtype_class(DBTYPE type
)
1229 case DBTYPE_DBTIMESTAMP
:
1230 return DBTYPE_DBDATE
;
1235 /* Many src types will convert to this group of dst types */
1236 static inline BOOL
common_class(WORD dst_class
)
1246 case DBTYPE_VARIANT
:
1249 case DBTYPE_DECIMAL
:
1250 case DBTYPE_NUMERIC
:
1256 static inline BOOL
array_type(DBTYPE type
)
1258 return (type
>= DBTYPE_I2
&& type
<= DBTYPE_UI4
);
1261 static HRESULT WINAPI
convert_CanConvert(IDataConvert
* iface
,
1262 DBTYPE src_type
, DBTYPE dst_type
)
1264 convert
*This
= impl_from_IDataConvert(iface
);
1265 DBTYPE src_base_type
= src_type
& 0x1ff;
1266 DBTYPE dst_base_type
= dst_type
& 0x1ff;
1267 WORD dst_class
= get_dbtype_class(dst_base_type
);
1269 TRACE("(%p)->(%d, %d)\n", This
, src_type
, dst_type
);
1271 if(src_type
& DBTYPE_VECTOR
|| dst_type
& DBTYPE_VECTOR
) return S_FALSE
;
1273 if(src_type
& DBTYPE_ARRAY
)
1275 if(!array_type(src_base_type
)) return S_FALSE
;
1276 if(dst_type
& DBTYPE_ARRAY
)
1278 if(src_type
== dst_type
) return S_OK
;
1281 if(dst_type
== DBTYPE_VARIANT
) return S_OK
;
1285 if(dst_type
& DBTYPE_ARRAY
)
1287 if(!array_type(dst_base_type
)) return S_FALSE
;
1288 if(src_type
== DBTYPE_IDISPATCH
|| src_type
== DBTYPE_VARIANT
) return S_OK
;
1292 if(dst_type
& DBTYPE_BYREF
)
1293 if(dst_base_type
!= DBTYPE_BYTES
&& dst_base_type
!= DBTYPE_STR
&& dst_base_type
!= DBTYPE_WSTR
)
1296 switch(get_dbtype_class(src_base_type
))
1299 if(common_class(dst_class
)) return S_OK
;
1304 case DBTYPE_FILETIME
:
1307 if(dst_base_type
== DBTYPE_DBTIMESTAMP
) return S_OK
;
1312 switch(dst_base_type
)
1315 case DBTYPE_VARIANT
:
1316 case DBTYPE_FILETIME
: return S_OK
;
1317 default: return S_FALSE
;
1321 if(dst_base_type
== DBTYPE_BYTES
) return S_OK
;
1324 if(dst_base_type
== DBTYPE_DATE
) return S_OK
;
1326 case DBTYPE_DECIMAL
:
1327 if(common_class(dst_class
)) return S_OK
;
1328 if(dst_class
== DBTYPE_DBDATE
) return S_OK
;
1332 if(dst_base_type
== DBTYPE_DATE
) return S_OK
;
1334 case DBTYPE_NUMERIC
:
1336 if(common_class(dst_class
)) return S_OK
;
1340 if(common_class(dst_class
)) return S_OK
;
1341 switch(dst_base_type
)
1344 case DBTYPE_FILETIME
: return S_OK
;
1345 default: return S_FALSE
;
1357 case DBTYPE_VARIANT
:
1361 case DBTYPE_FILETIME
:
1363 default: return S_FALSE
;
1366 case DBTYPE_IDISPATCH
:
1367 case DBTYPE_VARIANT
:
1368 switch(dst_base_type
)
1370 case DBTYPE_IDISPATCH
:
1372 case DBTYPE_IUNKNOWN
:
1377 if(common_class(dst_class
)) return S_OK
;
1384 case DBTYPE_FILETIME
:
1386 default: return S_FALSE
;
1390 switch(dst_base_type
)
1394 case DBTYPE_VARIANT
:
1397 default: return S_FALSE
;
1400 case DBTYPE_IUNKNOWN
:
1401 switch(dst_base_type
)
1405 case DBTYPE_IDISPATCH
:
1406 case DBTYPE_VARIANT
:
1407 case DBTYPE_IUNKNOWN
:
1409 default: return S_FALSE
;
1413 if(dst_class
== DBTYPE_I4
|| dst_class
== DBTYPE_I8
) return S_OK
;
1421 case DBTYPE_VARIANT
:
1425 default: return S_FALSE
;
1428 case DBTYPE_FILETIME
:
1429 if(dst_class
== DBTYPE_I8
) return S_OK
;
1438 case DBTYPE_VARIANT
:
1440 case DBTYPE_FILETIME
:
1442 default: return S_FALSE
;
1449 static HRESULT WINAPI
convert_GetConversionSize(IDataConvert
* iface
,
1450 DBTYPE src_type
, DBTYPE dst_type
,
1451 DBLENGTH
*src_len
, DBLENGTH
*dst_len
,
1454 convert
*This
= impl_from_IDataConvert(iface
);
1457 TRACE("(%p)->(%d, %d, %p, %p, %p)\n", This
, src_type
, dst_type
, src_len
, dst_len
, src
);
1459 hr
= IDataConvert_CanConvert(iface
, src_type
, dst_type
);
1461 return DB_E_UNSUPPORTEDCONVERSION
;
1464 return E_INVALIDARG
;
1466 /* for some types we don't need to look into source data */
1467 if ((*dst_len
= get_length(dst_type
)))
1472 if(src_type
== DBTYPE_VARIANT
&& V_VT((VARIANT
*)src
) == VT_NULL
)
1480 case DBTYPE_VARIANT
:
1485 if ((hr
= VariantChangeType(&v
, src
, 0, VT_BSTR
)) == S_OK
)
1487 *dst_len
= WideCharToMultiByte(CP_ACP
, 0, V_BSTR(&v
), -1, NULL
, 0, NULL
, NULL
);
1495 case DBTYPE_DECIMAL
:
1506 case DBTYPE_DBTIMESTAMP
:
1510 FIXME("unimplemented for %04x -> DBTYPE_STR\n", src_type
);
1517 case DBTYPE_VARIANT
:
1522 if ((hr
= VariantChangeType(&v
, src
, 0, VT_BSTR
)) == S_OK
)
1524 *dst_len
= (SysStringLen(V_BSTR(&v
))+1) * sizeof(WCHAR
);
1531 *dst_len
= (*src_len
+ 1) * sizeof(WCHAR
);
1533 *dst_len
= (strlen(src
) + 1) * sizeof(WCHAR
);
1537 *dst_len
= (*src_len
) + sizeof(WCHAR
);
1539 *dst_len
= (lstrlenW(src
) + 1) * sizeof(WCHAR
);
1542 case DBTYPE_DECIMAL
:
1553 case DBTYPE_DBTIMESTAMP
:
1557 FIXME("unimplemented for %04x -> DBTYPE_WSTR\n", src_type
);
1564 case DBTYPE_VARIANT
:
1565 if(V_VT((VARIANT
*)src
) == VT_BSTR
)
1566 *dst_len
= (SysStringLen(V_BSTR((VARIANT
*)src
))) / sizeof(WCHAR
);
1569 switch(V_VT((VARIANT
*)src
))
1571 case VT_UI1
| VT_ARRAY
:
1575 hr
= SafeArrayGetUBound(V_ARRAY((VARIANT
*)src
), 1, &l
);
1583 WARN("DBTYPE_VARIANT(%d)->DBTYPE_BYTES unimplemented\n", V_VT((VARIANT
*)src
));
1588 FIXME("unimplemented for %04x -> DBTYPE_BYTES\n", src_type
);
1593 FIXME("unimplemented for conversion %d->%d\n", src_type
, dst_type
);
1600 static const struct IDataConvertVtbl convert_vtbl
=
1602 convert_QueryInterface
,
1605 convert_DataConvert
,
1607 convert_GetConversionSize
1610 static HRESULT WINAPI
dcinfo_QueryInterface(IDCInfo
* iface
, REFIID riid
, void **obj
)
1612 convert
*This
= impl_from_IDCInfo(iface
);
1614 return IDataConvert_QueryInterface(&This
->IDataConvert_iface
, riid
, obj
);
1617 static ULONG WINAPI
dcinfo_AddRef(IDCInfo
* iface
)
1619 convert
*This
= impl_from_IDCInfo(iface
);
1621 return IDataConvert_AddRef(&This
->IDataConvert_iface
);
1624 static ULONG WINAPI
dcinfo_Release(IDCInfo
* iface
)
1626 convert
*This
= impl_from_IDCInfo(iface
);
1628 return IDataConvert_Release(&This
->IDataConvert_iface
);
1631 static HRESULT WINAPI
dcinfo_GetInfo(IDCInfo
*iface
, ULONG num
, DCINFOTYPE types
[], DCINFO
**info_ptr
)
1633 convert
*This
= impl_from_IDCInfo(iface
);
1637 TRACE("(%p)->(%ld, %p, %p)\n", This
, num
, types
, info_ptr
);
1639 *info_ptr
= infos
= CoTaskMemAlloc(num
* sizeof(*infos
));
1640 if(!infos
) return E_OUTOFMEMORY
;
1642 for(i
= 0; i
< num
; i
++)
1644 infos
[i
].eInfoType
= types
[i
];
1645 VariantInit(&infos
[i
].vData
);
1649 case DCINFOTYPE_VERSION
:
1650 V_VT(&infos
[i
].vData
) = VT_UI4
;
1651 V_UI4(&infos
[i
].vData
) = This
->version
;
1659 static HRESULT WINAPI
dcinfo_SetInfo(IDCInfo
* iface
, ULONG num
, DCINFO info
[])
1661 convert
*This
= impl_from_IDCInfo(iface
);
1665 TRACE("(%p)->(%ld, %p)\n", This
, num
, info
);
1667 for(i
= 0; i
< num
; i
++)
1669 switch(info
[i
].eInfoType
)
1671 case DCINFOTYPE_VERSION
:
1672 if(V_VT(&info
[i
].vData
) != VT_UI4
)
1674 FIXME("VERSION with vt %x\n", V_VT(&info
[i
].vData
));
1675 hr
= DB_S_ERRORSOCCURRED
;
1678 This
->version
= V_UI4(&info
[i
].vData
);
1682 FIXME("Unhandled info type %ld (vt %x)\n", info
[i
].eInfoType
, V_VT(&info
[i
].vData
));
1688 static const struct IDCInfoVtbl dcinfo_vtbl
=
1690 dcinfo_QueryInterface
,
1697 HRESULT
create_oledb_convert(IUnknown
*outer
, void **obj
)
1701 TRACE("(%p, %p)\n", outer
, obj
);
1705 if(outer
) return CLASS_E_NOAGGREGATION
;
1707 This
= malloc(sizeof(*This
));
1708 if(!This
) return E_OUTOFMEMORY
;
1710 This
->IDataConvert_iface
.lpVtbl
= &convert_vtbl
;
1711 This
->IDCInfo_iface
.lpVtbl
= &dcinfo_vtbl
;
1713 This
->version
= 0x110;
1715 *obj
= &This
->IDataConvert_iface
;