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
);
135 return sizeof(DBDATE
);
136 case DBTYPE_DBTIMESTAMP
:
137 return sizeof(DBTIMESTAMP
);
142 case DBTYPE_FILETIME
:
143 return sizeof(FILETIME
);
149 case DBTYPE_BYREF
| DBTYPE_WSTR
:
152 return sizeof(VARIANT
);
154 FIXME("Unhandled type %04x\n", type
);
159 static HRESULT WINAPI
convert_DataConvert(IDataConvert
* iface
,
160 DBTYPE src_type
, DBTYPE dst_type
,
161 DBLENGTH src_len
, DBLENGTH
*dst_len
,
162 void *src
, void *dst
,
163 DBLENGTH dst_max_len
,
164 DBSTATUS src_status
, DBSTATUS
*dst_status
,
165 BYTE precision
, BYTE scale
,
168 convert
*This
= impl_from_IDataConvert(iface
);
169 DBLENGTH dst_len_loc
;
170 DBSTATUS dst_status_loc
;
174 TRACE("(%p)->(%d, %d, %ld, %p, %p, %p, %ld, %d, %p, %d, %d, %x)\n", This
,
175 src_type
, dst_type
, src_len
, dst_len
, src
, dst
, dst_max_len
,
176 src_status
, dst_status
, precision
, scale
, flags
);
178 if (!dst_len
) dst_len
= &dst_len_loc
;
179 if (!dst_status
) dst_status
= &dst_status_loc
;
181 *dst_status
= DBSTATUS_E_BADACCESSOR
;
183 if(src_status
== DBSTATUS_S_ISNULL
)
185 *dst_status
= DBSTATUS_S_ISNULL
;
190 if(IDataConvert_CanConvert(iface
, src_type
, dst_type
) != S_OK
)
192 return DB_E_UNSUPPORTEDCONVERSION
;
195 if(dst
== NULL
&& get_length(dst_type
) != 0)
197 *dst_len
= get_length(src_type
);
198 *dst_status
= DBSTATUS_S_OK
;
202 if(src_type
== DBTYPE_STR
)
207 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
208 len
= MultiByteToWideChar(CP_ACP
, 0, src
, -1, NULL
, 0) - 1;
210 len
= MultiByteToWideChar(CP_ACP
, 0, src
, src_len
, NULL
, 0);
211 b
= SysAllocStringLen(NULL
, len
);
212 if(!b
) return E_OUTOFMEMORY
;
213 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
214 MultiByteToWideChar(CP_ACP
, 0, src
, -1, b
, len
+ 1);
216 MultiByteToWideChar(CP_ACP
, 0, src
, src_len
, b
, len
);
218 hr
= IDataConvert_DataConvert(iface
, DBTYPE_BSTR
, dst_type
, 0, dst_len
,
219 &b
, dst
, dst_max_len
, src_status
, dst_status
,
220 precision
, scale
, flags
);
226 if(src_type
== DBTYPE_WSTR
)
230 if(flags
& DBDATACONVERT_LENGTHFROMNTS
)
231 b
= SysAllocString(src
);
233 b
= SysAllocStringLen(src
, src_len
/ 2);
234 if(!b
) return E_OUTOFMEMORY
;
235 hr
= IDataConvert_DataConvert(iface
, DBTYPE_BSTR
, dst_type
, 0, dst_len
,
236 &b
, dst
, dst_max_len
, src_status
, dst_status
,
237 precision
, scale
, flags
);
246 signed short *d
= dst
;
249 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
250 case DBTYPE_I2
: *d
= *(signed short*)src
; hr
= S_OK
; break;
251 case DBTYPE_I4
: hr
= VarI2FromI4(*(signed int*)src
, d
); break;
252 case DBTYPE_R4
: hr
= VarI2FromR4(*(FLOAT
*)src
, d
); break;
253 case DBTYPE_R8
: hr
= VarI2FromR8(*(double*)src
, d
); break;
254 case DBTYPE_CY
: hr
= VarI2FromCy(*(CY
*)src
, d
); break;
255 case DBTYPE_DATE
: hr
= VarI2FromDate(*(DATE
*)src
, d
); break;
256 case DBTYPE_BSTR
: hr
= VarI2FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
257 case DBTYPE_BOOL
: hr
= VarI2FromBool(*(VARIANT_BOOL
*)src
, d
); break;
258 case DBTYPE_DECIMAL
: hr
= VarI2FromDec((DECIMAL
*)src
, d
); break;
259 case DBTYPE_I1
: hr
= VarI2FromI1(*(signed char*)src
, d
); break;
260 case DBTYPE_UI1
: hr
= VarI2FromUI1(*(BYTE
*)src
, d
); break;
261 case DBTYPE_UI2
: hr
= VarI2FromUI2(*(WORD
*)src
, d
); break;
262 case DBTYPE_UI4
: hr
= VarI2FromUI4(*(DWORD
*)src
, d
); break;
263 case DBTYPE_I8
: hr
= VarI2FromI8(*(LONGLONG
*)src
, d
); break;
264 case DBTYPE_UI8
: hr
= VarI2FromUI8(*(ULONGLONG
*)src
, d
); break;
267 if ((hr
= VariantChangeType(&tmp
, (VARIANT
*)src
, 0, VT_I2
)) == S_OK
)
270 default: FIXME("Unimplemented conversion %04x -> I2\n", src_type
); return E_NOTIMPL
;
280 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
281 case DBTYPE_I2
: hr
= VarI4FromI2(*(signed short*)src
, d
); break;
282 case DBTYPE_I4
: *d
= *(signed int*)src
; hr
= S_OK
; break;
283 case DBTYPE_R4
: hr
= VarI4FromR4(*(FLOAT
*)src
, d
); break;
284 case DBTYPE_R8
: hr
= VarI4FromR8(*(double*)src
, d
); break;
285 case DBTYPE_CY
: hr
= VarI4FromCy(*(CY
*)src
, d
); break;
286 case DBTYPE_DATE
: hr
= VarI4FromDate(*(DATE
*)src
, d
); break;
287 case DBTYPE_BSTR
: hr
= VarI4FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
288 case DBTYPE_BOOL
: hr
= VarI4FromBool(*(VARIANT_BOOL
*)src
, d
); break;
289 case DBTYPE_DECIMAL
: hr
= VarI4FromDec((DECIMAL
*)src
, d
); break;
290 case DBTYPE_I1
: hr
= VarI4FromI1(*(signed char*)src
, d
); break;
291 case DBTYPE_UI1
: hr
= VarI4FromUI1(*(BYTE
*)src
, d
); break;
292 case DBTYPE_UI2
: hr
= VarI4FromUI2(*(WORD
*)src
, d
); break;
293 case DBTYPE_UI4
: hr
= VarI4FromUI4(*(DWORD
*)src
, d
); break;
294 case DBTYPE_I8
: hr
= VarI4FromI8(*(LONGLONG
*)src
, d
); break;
295 case DBTYPE_UI8
: hr
= VarI4FromUI8(*(ULONGLONG
*)src
, d
); break;
298 if ((hr
= VariantChangeType(&tmp
, (VARIANT
*)src
, 0, VT_I4
)) == S_OK
)
301 default: FIXME("Unimplemented conversion %04x -> I4\n", src_type
); return E_NOTIMPL
;
311 case DBTYPE_BSTR
: hr
= VarI8FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
312 case DBTYPE_I8
: *d
= *(LONGLONG
*)src
; hr
= S_OK
; break;
313 default: FIXME("Unimplemented conversion %04x -> I8\n", src_type
); return E_NOTIMPL
;
323 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
324 case DBTYPE_I2
: hr
= VarR4FromI2(*(signed short*)src
, d
); break;
325 case DBTYPE_I4
: hr
= VarR4FromI4(*(signed int*)src
, d
); break;
326 case DBTYPE_R4
: *d
= *(FLOAT
*)src
; hr
= S_OK
; break;
327 case DBTYPE_R8
: hr
= VarR4FromR8(*(double*)src
, d
); break;
328 case DBTYPE_CY
: hr
= VarR4FromCy(*(CY
*)src
, d
); break;
329 case DBTYPE_DATE
: hr
= VarR4FromDate(*(DATE
*)src
, d
); break;
330 case DBTYPE_BSTR
: hr
= VarR4FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
331 case DBTYPE_BOOL
: hr
= VarR4FromBool(*(VARIANT_BOOL
*)src
, d
); break;
332 case DBTYPE_DECIMAL
: hr
= VarR4FromDec((DECIMAL
*)src
, d
); break;
333 case DBTYPE_I1
: hr
= VarR4FromI1(*(signed char*)src
, d
); break;
334 case DBTYPE_UI1
: hr
= VarR4FromUI1(*(BYTE
*)src
, d
); break;
335 case DBTYPE_UI2
: hr
= VarR4FromUI2(*(WORD
*)src
, d
); break;
336 case DBTYPE_UI4
: hr
= VarR4FromUI4(*(DWORD
*)src
, d
); break;
337 case DBTYPE_I8
: hr
= VarR4FromI8(*(LONGLONG
*)src
, d
); break;
338 case DBTYPE_UI8
: hr
= VarR4FromUI8(*(ULONGLONG
*)src
, d
); break;
339 default: FIXME("Unimplemented conversion %04x -> R4\n", src_type
); return E_NOTIMPL
;
348 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
349 case DBTYPE_I1
: hr
= VarR8FromI1(*(signed char*)src
, d
); break;
350 case DBTYPE_I2
: hr
= VarR8FromI2(*(signed short*)src
, d
); break;
351 case DBTYPE_I4
: hr
= VarR8FromI4(*(signed int*)src
, d
); break;
352 case DBTYPE_I8
: hr
= VarR8FromI8(*(LONGLONG
*)src
, d
); break;
353 case DBTYPE_UI1
: hr
= VarR8FromUI1(*(BYTE
*)src
, d
); break;
354 case DBTYPE_UI2
: hr
= VarR8FromUI2(*(WORD
*)src
, d
); break;
355 case DBTYPE_UI4
: hr
= VarR8FromUI4(*(DWORD
*)src
, d
); break;
356 case DBTYPE_UI8
: hr
= VarR8FromUI8(*(ULONGLONG
*)src
, d
); break;
357 case DBTYPE_R4
: hr
= VarR8FromR4(*(FLOAT
*)src
, d
); break;
358 case DBTYPE_R8
: *d
= *(DOUBLE
*)src
; hr
= S_OK
; break;
359 case DBTYPE_CY
: hr
= VarR8FromCy(*(CY
*)src
, d
); break;
360 case DBTYPE_DATE
: hr
= VarR8FromDate(*(DATE
*)src
, d
); break;
361 case DBTYPE_BSTR
: hr
= VarR8FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
362 case DBTYPE_BOOL
: hr
= VarR8FromBool(*(VARIANT_BOOL
*)src
, d
); break;
363 case DBTYPE_DECIMAL
: hr
= VarR8FromDec((DECIMAL
*)src
, d
); break;
364 default: FIXME("Unimplemented conversion %04x -> R8\n", src_type
); return E_NOTIMPL
;
373 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
374 case DBTYPE_I1
: hr
= VarBoolFromI1(*(signed char*)src
, d
); break;
375 case DBTYPE_I2
: hr
= VarBoolFromI2(*(signed short*)src
, d
); break;
376 case DBTYPE_I4
: hr
= VarBoolFromI4(*(signed int*)src
, d
); break;
377 case DBTYPE_I8
: hr
= VarBoolFromI8(*(LONGLONG
*)src
, d
); break;
378 case DBTYPE_UI1
: hr
= VarBoolFromUI1(*(BYTE
*)src
, d
); break;
379 case DBTYPE_UI2
: hr
= VarBoolFromUI2(*(WORD
*)src
, d
); break;
380 case DBTYPE_UI4
: hr
= VarBoolFromUI4(*(DWORD
*)src
, d
); break;
381 case DBTYPE_UI8
: hr
= VarBoolFromUI8(*(ULONGLONG
*)src
, d
); break;
382 case DBTYPE_R4
: hr
= VarBoolFromR4(*(FLOAT
*)src
, d
); break;
383 case DBTYPE_R8
: hr
= VarBoolFromR8(*(DOUBLE
*)src
, d
); break;
384 case DBTYPE_CY
: hr
= VarBoolFromCy(*(CY
*)src
, d
); break;
385 case DBTYPE_DATE
: hr
= VarBoolFromDate(*(DATE
*)src
, d
); break;
386 case DBTYPE_BSTR
: hr
= VarBoolFromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
387 case DBTYPE_BOOL
: *d
= *(VARIANT_BOOL
*)src
; hr
= S_OK
; break;
388 case DBTYPE_DECIMAL
: hr
= VarBoolFromDec((DECIMAL
*)src
, d
); break;
389 default: FIXME("Unimplemented conversion %04x -> BOOL\n", src_type
); return E_NOTIMPL
;
398 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
399 case DBTYPE_I1
: hr
= VarDateFromI1(*(signed char*)src
, d
); break;
400 case DBTYPE_I2
: hr
= VarDateFromI2(*(signed short*)src
, d
); break;
401 case DBTYPE_I4
: hr
= VarDateFromI4(*(signed int*)src
, d
); break;
402 case DBTYPE_I8
: hr
= VarDateFromI8(*(LONGLONG
*)src
, d
); break;
403 case DBTYPE_UI1
: hr
= VarDateFromUI1(*(BYTE
*)src
, d
); break;
404 case DBTYPE_UI2
: hr
= VarDateFromUI2(*(WORD
*)src
, d
); break;
405 case DBTYPE_UI4
: hr
= VarDateFromUI4(*(DWORD
*)src
, d
); break;
406 case DBTYPE_UI8
: hr
= VarDateFromUI8(*(ULONGLONG
*)src
, d
); break;
407 case DBTYPE_R4
: hr
= VarDateFromR4(*(FLOAT
*)src
, d
); break;
408 case DBTYPE_R8
: hr
= VarDateFromR8(*(DOUBLE
*)src
, d
); break;
409 case DBTYPE_CY
: hr
= VarDateFromCy(*(CY
*)src
, d
); break;
410 case DBTYPE_DATE
: *d
= *(DATE
*)src
; hr
= S_OK
; break;
411 case DBTYPE_BSTR
: hr
= VarDateFromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
412 case DBTYPE_BOOL
: hr
= VarDateFromBool(*(VARIANT_BOOL
*)src
, d
); break;
413 case DBTYPE_DECIMAL
: hr
= VarDateFromDec((DECIMAL
*)src
, d
); break;
414 case DBTYPE_DBTIMESTAMP
:
417 DBTIMESTAMP
*ts
=(DBTIMESTAMP
*)src
;
420 st
.wMonth
= ts
->month
;
423 st
.wMinute
= ts
->minute
;
424 st
.wSecond
= ts
->second
;
425 st
.wMilliseconds
= ts
->fraction
/1000000;
426 hr
= (SystemTimeToVariantTime(&st
, d
) ? S_OK
: E_FAIL
);
429 default: FIXME("Unimplemented conversion %04x -> DATE\n", src_type
); return E_NOTIMPL
;
438 case DBTYPE_DBDATE
: memcpy(d
, src
, sizeof(DBDATE
)); hr
= S_OK
; break;
442 BSTR s
= *(WCHAR
**)src
;
445 V_VT(&var
) = VT_BSTR
;
446 V_BSTR(&var
) = SysAllocString(s
);
448 if ((hr
= VariantChangeType(&var
, &var
, 0, VT_DATE
)) == S_OK
)
451 hr
= (VariantTimeToSystemTime( V_DATE(&var
), &st
) ? S_OK
: E_FAIL
);
453 d
->month
= st
.wMonth
;
461 if( V_VT((VARIANT
*)src
) == VT_DATE
)
464 hr
= (VariantTimeToSystemTime( V_DATE((VARIANT
*)src
), &st
) ? S_OK
: E_FAIL
);
466 d
->month
= st
.wMonth
;
471 FIXME("Unimplemented variant type %d -> DBDATE\n", V_VT((VARIANT
*)src
));
475 default: FIXME("Unimplemented conversion %04x -> DBDATE\n", src_type
); return E_NOTIMPL
;
479 case DBTYPE_DBTIMESTAMP
:
484 case DBTYPE_EMPTY
: memset(d
, 0, sizeof(DBTIMESTAMP
)); hr
= S_OK
; break;
485 case DBTYPE_DBTIMESTAMP
: memcpy(d
, src
, sizeof(DBTIMESTAMP
)); hr
= S_OK
; break;
489 BSTR s
= *(WCHAR
**)src
;
492 V_VT(&var
) = VT_BSTR
;
493 V_BSTR(&var
) = SysAllocString(s
);
495 if ((hr
= VariantChangeType(&var
, &var
, 0, VT_DATE
)) == S_OK
)
499 hr
= (VariantTimeToSystemTime( V_DATE(&var
), &st
) ? S_OK
: E_FAIL
);
501 d
->month
= st
.wMonth
;
504 d
->minute
= st
.wMinute
;
505 d
->second
= st
.wSecond
;
506 d
->fraction
= st
.wMilliseconds
* 1000000;
515 hr
= (VariantTimeToSystemTime(*(double*)src
, &st
) ? S_OK
: E_FAIL
);
517 d
->month
= st
.wMonth
;
520 d
->minute
= st
.wMinute
;
521 d
->second
= st
.wSecond
;
522 d
->fraction
= st
.wMilliseconds
* 1000000;
526 if( V_VT((VARIANT
*)src
) == VT_DATE
)
529 hr
= (VariantTimeToSystemTime( V_DATE((VARIANT
*)src
), &st
) ? S_OK
: E_FAIL
);
531 d
->month
= st
.wMonth
;
534 d
->minute
= st
.wMinute
;
535 d
->second
= st
.wSecond
;
536 d
->fraction
= st
.wMilliseconds
* 1000000;
540 FIXME("Unimplemented variant type %d -> DBTIMESTAMP\n", V_VT((VARIANT
*)src
));
544 default: FIXME("Unimplemented conversion %04x -> DBTIMESTAMP\n", src_type
); return E_NOTIMPL
;
554 case DBTYPE_EMPTY
: d
->int64
= 0; hr
= S_OK
; break;
555 case DBTYPE_I2
: hr
= VarCyFromI2(*(signed short*)src
, d
); break;
556 case DBTYPE_I4
: hr
= VarCyFromI4(*(signed int*)src
, d
); break;
557 case DBTYPE_R4
: hr
= VarCyFromR4(*(FLOAT
*)src
, d
); break;
558 case DBTYPE_R8
: hr
= VarCyFromR8(*(double*)src
, d
); break;
559 case DBTYPE_CY
: *d
= *(CY
*)src
; hr
= S_OK
; break;
560 case DBTYPE_DATE
: hr
= VarCyFromDate(*(DATE
*)src
, d
); break;
561 case DBTYPE_BSTR
: hr
= VarCyFromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
562 case DBTYPE_BOOL
: hr
= VarCyFromBool(*(VARIANT_BOOL
*)src
, d
); break;
563 case DBTYPE_DECIMAL
: hr
= VarCyFromDec((DECIMAL
*)src
, d
); break;
564 case DBTYPE_I1
: hr
= VarCyFromI1(*(signed char*)src
, d
); break;
565 case DBTYPE_UI1
: hr
= VarCyFromUI1(*(BYTE
*)src
, d
); break;
566 case DBTYPE_UI2
: hr
= VarCyFromUI2(*(WORD
*)src
, d
); break;
567 case DBTYPE_UI4
: hr
= VarCyFromUI4(*(DWORD
*)src
, d
); break;
568 case DBTYPE_I8
: hr
= VarCyFromI8(*(LONGLONG
*)src
, d
); break;
569 case DBTYPE_UI8
: hr
= VarCyFromUI8(*(ULONGLONG
*)src
, d
); break;
570 default: FIXME("Unimplemented conversion %04x -> CY\n", src_type
); return E_NOTIMPL
;
580 case DBTYPE_EMPTY
: *d
= SysAllocStringLen(NULL
, 0); hr
= *d
? S_OK
: E_OUTOFMEMORY
; break;
581 case DBTYPE_I2
: hr
= VarBstrFromI2(*(signed short*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
582 case DBTYPE_I4
: hr
= VarBstrFromI4(*(signed int*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
583 case DBTYPE_R4
: hr
= VarBstrFromR4(*(FLOAT
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
584 case DBTYPE_R8
: hr
= VarBstrFromR8(*(double*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
585 case DBTYPE_CY
: hr
= VarBstrFromCy(*(CY
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
586 case DBTYPE_DATE
: hr
= VarBstrFromDate(*(DATE
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
587 case DBTYPE_BSTR
: *d
= SysAllocStringLen(*(BSTR
*)src
, SysStringLen(*(BSTR
*)src
)); hr
= *d
? S_OK
: E_OUTOFMEMORY
; break;
588 case DBTYPE_BOOL
: hr
= VarBstrFromBool(*(VARIANT_BOOL
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
589 case DBTYPE_DECIMAL
: hr
= VarBstrFromDec((DECIMAL
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
590 case DBTYPE_I1
: hr
= VarBstrFromI1(*(signed char*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
591 case DBTYPE_UI1
: hr
= VarBstrFromUI1(*(BYTE
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
592 case DBTYPE_UI2
: hr
= VarBstrFromUI2(*(WORD
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
593 case DBTYPE_UI4
: hr
= VarBstrFromUI4(*(DWORD
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
594 case DBTYPE_I8
: hr
= VarBstrFromI8(*(LONGLONG
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
595 case DBTYPE_UI8
: hr
= VarBstrFromUI8(*(ULONGLONG
*)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
599 const GUID
*id
= (const GUID
*)src
;
601 '{','%','0','8','X','-','%','0','4','X','-','%','0','4','X','-',
602 '%','0','2','X','%','0','2','X','-',
603 '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','}',0};
604 wsprintfW(szBuff
, format
,
605 id
->Data1
, id
->Data2
, id
->Data3
,
606 id
->Data4
[0], id
->Data4
[1], id
->Data4
[2], id
->Data4
[3],
607 id
->Data4
[4], id
->Data4
[5], id
->Data4
[6], id
->Data4
[7] );
608 *d
= SysAllocString(szBuff
);
609 hr
= *d
? S_OK
: E_OUTOFMEMORY
;
614 *d
= SysAllocStringLen(NULL
, 2 * src_len
);
619 const char hexchars
[] = "0123456789ABCDEF";
621 unsigned char *p
= src
;
624 *s
++ = hexchars
[(*p
>> 4) & 0x0F];
625 *s
++ = hexchars
[(*p
) & 0x0F];
633 if(V_VT((VARIANT
*)src
) == VT_NULL
)
635 *dst_status
= DBSTATUS_S_ISNULL
;
636 *dst_len
= get_length(DBTYPE_BSTR
);
642 if ((hr
= VariantChangeType(&tmp
, (VARIANT
*)src
, 0, VT_BSTR
)) == S_OK
)
646 default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type
); return E_NOTIMPL
;
656 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
657 case DBTYPE_I2
: hr
= VarUI1FromI2(*(signed short*)src
, d
); break;
658 case DBTYPE_I4
: hr
= VarUI1FromI4(*(signed int*)src
, d
); break;
659 case DBTYPE_R4
: hr
= VarUI1FromR4(*(FLOAT
*)src
, d
); break;
660 case DBTYPE_R8
: hr
= VarUI1FromR8(*(double*)src
, d
); break;
661 case DBTYPE_CY
: hr
= VarUI1FromCy(*(CY
*)src
, d
); break;
662 case DBTYPE_DATE
: hr
= VarUI1FromDate(*(DATE
*)src
, d
); break;
663 case DBTYPE_BSTR
: hr
= VarUI1FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
664 case DBTYPE_BOOL
: hr
= VarUI1FromBool(*(VARIANT_BOOL
*)src
, d
); break;
665 case DBTYPE_DECIMAL
: hr
= VarUI1FromDec((DECIMAL
*)src
, d
); break;
666 case DBTYPE_I1
: hr
= VarUI1FromI1(*(signed char*)src
, d
); break;
667 case DBTYPE_UI1
: *d
= *(BYTE
*)src
; hr
= S_OK
; break;
668 case DBTYPE_UI2
: hr
= VarUI1FromUI2(*(WORD
*)src
, d
); break;
669 case DBTYPE_UI4
: hr
= VarUI1FromUI4(*(DWORD
*)src
, d
); break;
670 case DBTYPE_I8
: hr
= VarUI1FromI8(*(LONGLONG
*)src
, d
); break;
671 case DBTYPE_UI8
: hr
= VarUI1FromUI8(*(ULONGLONG
*)src
, d
); break;
672 default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type
); return E_NOTIMPL
;
681 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
682 case DBTYPE_I2
: hr
= VarUI2FromI2(*(signed short*)src
, d
); break;
683 case DBTYPE_I4
: hr
= VarUI2FromI4(*(signed int*)src
, d
); break;
684 case DBTYPE_R4
: hr
= VarUI2FromR4(*(FLOAT
*)src
, d
); break;
685 case DBTYPE_R8
: hr
= VarUI2FromR8(*(double*)src
, d
); break;
686 case DBTYPE_CY
: hr
= VarUI2FromCy(*(CY
*)src
, d
); break;
687 case DBTYPE_DATE
: hr
= VarUI2FromDate(*(DATE
*)src
, d
); break;
688 case DBTYPE_BSTR
: hr
= VarUI2FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
689 case DBTYPE_BOOL
: hr
= VarUI2FromBool(*(VARIANT_BOOL
*)src
, d
); break;
690 case DBTYPE_DECIMAL
: hr
= VarUI2FromDec((DECIMAL
*)src
, d
); break;
691 case DBTYPE_I1
: hr
= VarUI2FromI1(*(signed char*)src
, d
); break;
692 case DBTYPE_UI1
: hr
= VarUI2FromUI1(*(BYTE
*)src
, d
); break;
693 case DBTYPE_UI2
: *d
= *(WORD
*)src
; hr
= S_OK
; break;
694 case DBTYPE_UI4
: hr
= VarUI2FromUI4(*(DWORD
*)src
, d
); break;
695 case DBTYPE_I8
: hr
= VarUI2FromI8(*(LONGLONG
*)src
, d
); break;
696 case DBTYPE_UI8
: hr
= VarUI2FromUI8(*(ULONGLONG
*)src
, d
); break;
697 default: FIXME("Unimplemented conversion %04x -> UI2\n", src_type
); return E_NOTIMPL
;
707 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
708 case DBTYPE_I2
: hr
= VarUI4FromI2(*(signed short*)src
, d
); break;
709 case DBTYPE_I4
: hr
= VarUI4FromI4(*(signed int*)src
, d
); break;
710 case DBTYPE_R4
: hr
= VarUI4FromR4(*(FLOAT
*)src
, d
); break;
711 case DBTYPE_R8
: hr
= VarUI4FromR8(*(double*)src
, d
); break;
712 case DBTYPE_CY
: hr
= VarUI4FromCy(*(CY
*)src
, d
); break;
713 case DBTYPE_DATE
: hr
= VarUI4FromDate(*(DATE
*)src
, d
); break;
714 case DBTYPE_BSTR
: hr
= VarUI4FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
715 case DBTYPE_BOOL
: hr
= VarUI4FromBool(*(VARIANT_BOOL
*)src
, d
); break;
716 case DBTYPE_DECIMAL
: hr
= VarUI4FromDec((DECIMAL
*)src
, d
); break;
717 case DBTYPE_I1
: hr
= VarUI4FromI1(*(signed char*)src
, d
); break;
718 case DBTYPE_UI1
: hr
= VarUI4FromUI1(*(BYTE
*)src
, d
); break;
719 case DBTYPE_UI2
: hr
= VarUI4FromUI2(*(WORD
*)src
, d
); break;
720 case DBTYPE_UI4
: *d
= *(DWORD
*)src
; hr
= S_OK
; break;
721 case DBTYPE_I8
: hr
= VarUI4FromI8(*(LONGLONG
*)src
, d
); break;
722 case DBTYPE_UI8
: hr
= VarUI4FromUI8(*(ULONGLONG
*)src
, d
); break;
725 if ((hr
= VariantChangeType(&tmp
, (VARIANT
*)src
, 0, VT_UI4
)) == S_OK
)
728 default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type
); return E_NOTIMPL
;
738 case DBTYPE_EMPTY
: *d
= 0; hr
= S_OK
; break;
739 case DBTYPE_I2
: hr
= VarUI8FromI2(*(signed short*)src
, d
); break;
740 case DBTYPE_I4
: {LONGLONG s
= *(signed int*)src
; hr
= VarUI8FromI8(s
, d
); break;}
741 case DBTYPE_R4
: hr
= VarUI8FromR4(*(FLOAT
*)src
, d
); break;
742 case DBTYPE_R8
: hr
= VarUI8FromR8(*(double*)src
, d
); break;
743 case DBTYPE_CY
: hr
= VarUI8FromCy(*(CY
*)src
, d
); break;
744 case DBTYPE_DATE
: hr
= VarUI8FromDate(*(DATE
*)src
, d
); break;
745 case DBTYPE_BSTR
: hr
= VarUI8FromStr(*(WCHAR
**)src
, LOCALE_USER_DEFAULT
, 0, d
); break;
746 case DBTYPE_BOOL
: hr
= VarUI8FromBool(*(VARIANT_BOOL
*)src
, d
); break;
747 case DBTYPE_DECIMAL
: hr
= VarUI8FromDec((DECIMAL
*)src
, d
); break;
748 case DBTYPE_I1
: hr
= VarUI8FromI1(*(signed char*)src
, d
); break;
749 case DBTYPE_UI1
: hr
= VarUI8FromUI1(*(BYTE
*)src
, d
); break;
750 case DBTYPE_UI2
: hr
= VarUI8FromUI2(*(WORD
*)src
, d
); break;
751 case DBTYPE_UI4
: hr
= VarUI8FromUI4(*(DWORD
*)src
, d
); break;
752 case DBTYPE_I8
: hr
= VarUI8FromI8(*(LONGLONG
*)src
, d
); break;
753 case DBTYPE_UI8
: *d
= *(ULONGLONG
*)src
; hr
= S_OK
; break;
754 default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type
); return E_NOTIMPL
;
759 case DBTYPE_FILETIME
:
764 case DBTYPE_EMPTY
: d
->dwLowDateTime
= d
->dwHighDateTime
= 0; hr
= S_OK
; break;
765 case DBTYPE_FILETIME
: *d
= *(FILETIME
*)src
; hr
= S_OK
; break;
766 default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type
); return E_NOTIMPL
;
776 case DBTYPE_EMPTY
: *d
= GUID_NULL
; hr
= S_OK
; break;
777 case DBTYPE_GUID
: *d
= *(GUID
*)src
; hr
= S_OK
; break;
778 default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type
); return E_NOTIMPL
;
788 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
789 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
790 precision
, scale
, flags
);
791 if(hr
!= S_OK
|| *dst_status
== DBSTATUS_S_ISNULL
)
793 bstr_len
= SysStringLen(b
);
794 *dst_len
= bstr_len
* sizeof(WCHAR
); /* Doesn't include size for '\0' */
795 *dst_status
= DBSTATUS_S_OK
;
796 bytes_to_copy
= min(*dst_len
+ sizeof(WCHAR
), dst_max_len
);
799 if(bytes_to_copy
>= sizeof(WCHAR
))
801 memcpy(dst
, b
, bytes_to_copy
- sizeof(WCHAR
));
802 *((WCHAR
*)dst
+ bytes_to_copy
/ sizeof(WCHAR
) - 1) = 0;
803 if(bytes_to_copy
< *dst_len
+ sizeof(WCHAR
))
804 *dst_status
= DBSTATUS_S_TRUNCATED
;
808 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
809 hr
= DB_E_ERRORSOCCURRED
;
820 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
821 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
822 precision
, scale
, flags
);
823 if(hr
!= S_OK
) return hr
;
824 bstr_len
= SysStringLen(b
);
825 *dst_len
= bstr_len
* sizeof(char); /* Doesn't include size for '\0' */
826 *dst_status
= DBSTATUS_S_OK
;
827 bytes_to_copy
= min(*dst_len
+ sizeof(char), dst_max_len
);
830 if(bytes_to_copy
>= sizeof(char))
832 WideCharToMultiByte(CP_ACP
, 0, b
, bytes_to_copy
- sizeof(char), dst
, dst_max_len
, NULL
, NULL
);
833 *((char *)dst
+ bytes_to_copy
/ sizeof(char) - 1) = 0;
834 if(bytes_to_copy
< *dst_len
+ sizeof(char))
835 *dst_status
= DBSTATUS_S_TRUNCATED
;
839 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
840 hr
= DB_E_ERRORSOCCURRED
;
847 case DBTYPE_BYREF
| DBTYPE_WSTR
:
852 hr
= IDataConvert_DataConvert(iface
, src_type
, DBTYPE_BSTR
, src_len
, &bstr_len
,
853 src
, &b
, sizeof(BSTR
), src_status
, dst_status
,
854 precision
, scale
, flags
);
855 if(hr
!= S_OK
) return hr
;
857 bstr_len
= SysStringLen(b
) * sizeof(WCHAR
);
858 *dst_len
= bstr_len
; /* Doesn't include size for '\0' */
860 *d
= CoTaskMemAlloc(bstr_len
+ sizeof(WCHAR
));
861 if(*d
) memcpy(*d
, b
, bstr_len
+ sizeof(WCHAR
));
862 else hr
= E_OUTOFMEMORY
;
875 V_BOOL(v
) = *(VARIANT_BOOL
*)src
;
880 V_I4(v
) = *(signed int*)src
;
884 V_VT(v
) = VT_DECIMAL
;
885 hr
= VarDecFromI8( *(LONGLONG
*)src
, &V_DECIMAL(v
));
889 V_R4(v
) = *(FLOAT
*)src
;
894 V_R8(v
) = *(double*)src
;
899 BSTR s
= *(WCHAR
**)src
;
900 TRACE("%s\n", debugstr_w(s
));
902 V_BSTR(v
) = SysAllocString(s
);
903 hr
= V_BSTR(v
) ? S_OK
: E_OUTOFMEMORY
;
908 V_DATE(v
) = *(DATE
*)src
;
914 DBDATE
*ts
=(DBDATE
*)src
;
919 st
.wMonth
= ts
->month
;
924 st
.wMilliseconds
= 0;
925 hr
= (SystemTimeToVariantTime(&st
, &V_DATE(v
)) ? S_OK
: E_FAIL
);
928 case DBTYPE_DBTIMESTAMP
:
931 DBTIMESTAMP
*ts
= (DBTIMESTAMP
*)src
;
936 st
.wMonth
= ts
->month
;
939 st
.wMinute
= ts
->minute
;
940 st
.wSecond
= ts
->second
;
941 st
.wMilliseconds
= ts
->fraction
/1000000;
942 hr
= SystemTimeToVariantTime(&st
, &V_DATE(v
)) ? S_OK
: E_FAIL
;
954 SAFEARRAY
*psa
= NULL
;
955 SAFEARRAYBOUND rgsabound
[1];
956 unsigned char *p
= src
;
958 size
= min(src_len
, dst_max_len
);
960 rgsabound
[0].lLbound
= 0;
961 rgsabound
[0].cElements
= size
;
963 psa
= SafeArrayCreate(VT_UI1
,1,rgsabound
);
964 for(i
=0; i
< size
; i
++,p
++)
966 hr
= SafeArrayPutElement(psa
, &i
, &p
);
968 SafeArrayDestroy (psa
);
973 V_VT(v
) = VT_ARRAY
|VT_UI1
;
978 default: FIXME("Unimplemented conversion %04x -> VARIANT\n", src_type
); return E_NOTIMPL
;
989 if( src_len
> dst_max_len
)
990 *dst_status
= DBSTATUS_S_TRUNCATED
;
992 *dst_status
= DBSTATUS_S_OK
;
995 memcpy(d
, src
, min(src_len
, dst_max_len
));
1000 if(V_VT((VARIANT
*)src
) == VT_NULL
)
1002 *dst_status
= DBSTATUS_S_ISNULL
;
1008 switch(V_VT((VARIANT
*)src
))
1010 case VT_UI1
| VT_ARRAY
:
1015 hr
= SafeArrayGetUBound(V_ARRAY((VARIANT
*)src
), 1, &l
);
1019 hr
= SafeArrayAccessData(V_ARRAY((VARIANT
*)src
), (VOID
**)&data
);
1022 ERR("SafeArrayAccessData Failed = 0x%08x\n", hr
);
1027 *dst_status
= DBSTATUS_S_OK
;
1028 memcpy(d
, data
, *dst_len
);
1030 SafeArrayUnaccessData(V_ARRAY((VARIANT
*)src
));
1035 FIXME("Unimplemented variant type %d -> BYTES\n", V_VT((VARIANT
*)src
));
1041 default: FIXME("Unimplemented conversion %04x -> DBTYPE_BYTES\n", src_type
); return E_NOTIMPL
;
1045 case DBTYPE_BYTES
| DBTYPE_BYREF
:
1052 *d
= CoTaskMemAlloc(src_len
);
1053 if(*d
) memcpy(*d
, src
, src_len
);
1054 else hr
= E_OUTOFMEMORY
;
1057 *dst_status
= DBSTATUS_S_OK
;
1059 default: FIXME("Unimplemented conversion %04x -> DBTYPE_BYTES | DBTYPE_BYREF\n", src_type
); return E_NOTIMPL
;
1066 FIXME("Unimplemented conversion %04x -> %04x\n", src_type
, dst_type
);
1070 if(hr
== DISP_E_OVERFLOW
)
1072 *dst_status
= DBSTATUS_E_DATAOVERFLOW
;
1073 *dst_len
= get_length(dst_type
);
1074 hr
= DB_E_ERRORSOCCURRED
;
1078 *dst_status
= DBSTATUS_S_OK
;
1079 *dst_len
= get_length(dst_type
);
1085 static inline WORD
get_dbtype_class(DBTYPE type
)
1112 case DBTYPE_DBTIMESTAMP
:
1113 return DBTYPE_DBDATE
;
1118 /* Many src types will convert to this group of dst types */
1119 static inline BOOL
common_class(WORD dst_class
)
1129 case DBTYPE_VARIANT
:
1132 case DBTYPE_DECIMAL
:
1133 case DBTYPE_NUMERIC
:
1139 static inline BOOL
array_type(DBTYPE type
)
1141 return (type
>= DBTYPE_I2
&& type
<= DBTYPE_UI4
);
1144 static HRESULT WINAPI
convert_CanConvert(IDataConvert
* iface
,
1145 DBTYPE src_type
, DBTYPE dst_type
)
1147 convert
*This
= impl_from_IDataConvert(iface
);
1148 DBTYPE src_base_type
= src_type
& 0x1ff;
1149 DBTYPE dst_base_type
= dst_type
& 0x1ff;
1150 WORD dst_class
= get_dbtype_class(dst_base_type
);
1152 TRACE("(%p)->(%d, %d)\n", This
, src_type
, dst_type
);
1154 if(src_type
& DBTYPE_VECTOR
|| dst_type
& DBTYPE_VECTOR
) return S_FALSE
;
1156 if(src_type
& DBTYPE_ARRAY
)
1158 if(!array_type(src_base_type
)) return S_FALSE
;
1159 if(dst_type
& DBTYPE_ARRAY
)
1161 if(src_type
== dst_type
) return S_OK
;
1164 if(dst_type
== DBTYPE_VARIANT
) return S_OK
;
1168 if(dst_type
& DBTYPE_ARRAY
)
1170 if(!array_type(dst_base_type
)) return S_FALSE
;
1171 if(src_type
== DBTYPE_IDISPATCH
|| src_type
== DBTYPE_VARIANT
) return S_OK
;
1175 if(dst_type
& DBTYPE_BYREF
)
1176 if(dst_base_type
!= DBTYPE_BYTES
&& dst_base_type
!= DBTYPE_STR
&& dst_base_type
!= DBTYPE_WSTR
)
1179 switch(get_dbtype_class(src_base_type
))
1182 if(common_class(dst_class
)) return S_OK
;
1187 case DBTYPE_FILETIME
:
1190 if(dst_base_type
== DBTYPE_DBTIMESTAMP
) return S_OK
;
1195 switch(dst_base_type
)
1198 case DBTYPE_VARIANT
:
1199 case DBTYPE_FILETIME
: return S_OK
;
1200 default: return S_FALSE
;
1204 if(dst_base_type
== DBTYPE_BYTES
) return S_OK
;
1207 if(dst_base_type
== DBTYPE_DATE
) return S_OK
;
1209 case DBTYPE_DECIMAL
:
1210 if(common_class(dst_class
)) return S_OK
;
1211 if(dst_class
== DBTYPE_DBDATE
) return S_OK
;
1215 if(dst_base_type
== DBTYPE_DATE
) return S_OK
;
1217 case DBTYPE_NUMERIC
:
1219 if(common_class(dst_class
)) return S_OK
;
1223 if(common_class(dst_class
)) return S_OK
;
1224 switch(dst_base_type
)
1227 case DBTYPE_FILETIME
: return S_OK
;
1228 default: return S_FALSE
;
1240 case DBTYPE_VARIANT
:
1244 case DBTYPE_FILETIME
:
1246 default: return S_FALSE
;
1249 case DBTYPE_IDISPATCH
:
1250 case DBTYPE_VARIANT
:
1251 switch(dst_base_type
)
1253 case DBTYPE_IDISPATCH
:
1255 case DBTYPE_IUNKNOWN
:
1260 if(common_class(dst_class
)) return S_OK
;
1267 case DBTYPE_FILETIME
:
1269 default: return S_FALSE
;
1273 switch(dst_base_type
)
1277 case DBTYPE_VARIANT
:
1280 default: return S_FALSE
;
1283 case DBTYPE_IUNKNOWN
:
1284 switch(dst_base_type
)
1288 case DBTYPE_IDISPATCH
:
1289 case DBTYPE_VARIANT
:
1290 case DBTYPE_IUNKNOWN
:
1292 default: return S_FALSE
;
1296 if(dst_class
== DBTYPE_I4
|| dst_class
== DBTYPE_I8
) return S_OK
;
1304 case DBTYPE_VARIANT
:
1308 default: return S_FALSE
;
1311 case DBTYPE_FILETIME
:
1312 if(dst_class
== DBTYPE_I8
) return S_OK
;
1321 case DBTYPE_VARIANT
:
1323 case DBTYPE_FILETIME
:
1325 default: return S_FALSE
;
1332 static HRESULT WINAPI
convert_GetConversionSize(IDataConvert
* iface
,
1333 DBTYPE src_type
, DBTYPE dst_type
,
1334 DBLENGTH
*src_len
, DBLENGTH
*dst_len
,
1337 convert
*This
= impl_from_IDataConvert(iface
);
1340 TRACE("(%p)->(%d, %d, %p, %p, %p)\n", This
, src_type
, dst_type
, src_len
, dst_len
, src
);
1342 hr
= IDataConvert_CanConvert(iface
, src_type
, dst_type
);
1344 return DB_E_UNSUPPORTEDCONVERSION
;
1347 return E_INVALIDARG
;
1349 /* for some types we don't need to look into source data */
1350 if ((*dst_len
= get_length(dst_type
)))
1358 case DBTYPE_VARIANT
:
1363 if ((hr
= VariantChangeType(&v
, (VARIANT
*)src
, 0, VT_BSTR
)) == S_OK
)
1365 *dst_len
= WideCharToMultiByte(CP_ACP
, 0, V_BSTR(&v
), -1, NULL
, 0, NULL
, NULL
);
1373 FIXME("unimplemented for %04x -> DBTYPE_STR\n", src_type
);
1380 case DBTYPE_VARIANT
:
1381 if(V_VT((VARIANT
*)src
) == VT_BSTR
)
1382 *dst_len
= (SysStringLen(V_BSTR((VARIANT
*)src
))+1) * sizeof(WCHAR
);
1384 WARN("DBTYPE_VARIANT(%d)->DBTYPE_WSTR unimplemented\n", V_VT((VARIANT
*)src
));
1388 *dst_len
= (*src_len
+ 1) * sizeof(WCHAR
);
1390 *dst_len
= (strlen(src
) + 1) * sizeof(WCHAR
);
1394 *dst_len
= (*src_len
) + sizeof(WCHAR
);
1396 *dst_len
= (lstrlenW(src
) + 1) * sizeof(WCHAR
);
1399 FIXME("unimplemented for %04x -> DBTYPE_WSTR\n", src_type
);
1406 case DBTYPE_VARIANT
:
1407 if(V_VT((VARIANT
*)src
) == VT_BSTR
)
1408 *dst_len
= (SysStringLen(V_BSTR((VARIANT
*)src
))) / sizeof(WCHAR
);
1411 switch(V_VT((VARIANT
*)src
))
1413 case VT_UI1
| VT_ARRAY
:
1417 hr
= SafeArrayGetUBound(V_ARRAY((VARIANT
*)src
), 1, &l
);
1425 WARN("DBTYPE_VARIANT(%d)->DBTYPE_BYTES unimplemented\n", V_VT((VARIANT
*)src
));
1430 FIXME("unimplemented for %04x -> DBTYPE_BYTES\n", src_type
);
1435 FIXME("unimplemented for conversion %d->%d\n", src_type
, dst_type
);
1442 static const struct IDataConvertVtbl convert_vtbl
=
1444 convert_QueryInterface
,
1447 convert_DataConvert
,
1449 convert_GetConversionSize
1452 static HRESULT WINAPI
dcinfo_QueryInterface(IDCInfo
* iface
, REFIID riid
, void **obj
)
1454 convert
*This
= impl_from_IDCInfo(iface
);
1456 return IDataConvert_QueryInterface(&This
->IDataConvert_iface
, riid
, obj
);
1459 static ULONG WINAPI
dcinfo_AddRef(IDCInfo
* iface
)
1461 convert
*This
= impl_from_IDCInfo(iface
);
1463 return IDataConvert_AddRef(&This
->IDataConvert_iface
);
1466 static ULONG WINAPI
dcinfo_Release(IDCInfo
* iface
)
1468 convert
*This
= impl_from_IDCInfo(iface
);
1470 return IDataConvert_Release(&This
->IDataConvert_iface
);
1473 static HRESULT WINAPI
dcinfo_GetInfo(IDCInfo
*iface
, ULONG num
, DCINFOTYPE types
[], DCINFO
**info_ptr
)
1475 convert
*This
= impl_from_IDCInfo(iface
);
1479 TRACE("(%p)->(%d, %p, %p)\n", This
, num
, types
, info_ptr
);
1481 *info_ptr
= infos
= CoTaskMemAlloc(num
* sizeof(*infos
));
1482 if(!infos
) return E_OUTOFMEMORY
;
1484 for(i
= 0; i
< num
; i
++)
1486 infos
[i
].eInfoType
= types
[i
];
1487 VariantInit(&infos
[i
].vData
);
1491 case DCINFOTYPE_VERSION
:
1492 V_VT(&infos
[i
].vData
) = VT_UI4
;
1493 V_UI4(&infos
[i
].vData
) = This
->version
;
1501 static HRESULT WINAPI
dcinfo_SetInfo(IDCInfo
* iface
, ULONG num
, DCINFO info
[])
1503 convert
*This
= impl_from_IDCInfo(iface
);
1507 TRACE("(%p)->(%d, %p)\n", This
, num
, info
);
1509 for(i
= 0; i
< num
; i
++)
1511 switch(info
[i
].eInfoType
)
1513 case DCINFOTYPE_VERSION
:
1514 if(V_VT(&info
[i
].vData
) != VT_UI4
)
1516 FIXME("VERSION with vt %x\n", V_VT(&info
[i
].vData
));
1517 hr
= DB_S_ERRORSOCCURRED
;
1520 This
->version
= V_UI4(&info
[i
].vData
);
1524 FIXME("Unhandled info type %d (vt %x)\n", info
[i
].eInfoType
, V_VT(&info
[i
].vData
));
1530 static const struct IDCInfoVtbl dcinfo_vtbl
=
1532 dcinfo_QueryInterface
,
1539 HRESULT
create_oledb_convert(IUnknown
*outer
, void **obj
)
1543 TRACE("(%p, %p)\n", outer
, obj
);
1547 if(outer
) return CLASS_E_NOAGGREGATION
;
1549 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
1550 if(!This
) return E_OUTOFMEMORY
;
1552 This
->IDataConvert_iface
.lpVtbl
= &convert_vtbl
;
1553 This
->IDCInfo_iface
.lpVtbl
= &dcinfo_vtbl
;
1555 This
->version
= 0x110;
1557 *obj
= &This
->IDataConvert_iface
;