1442 lines
44 KiB
C++
1442 lines
44 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1998 - 2000.
|
|
//
|
|
// File: odbvarnt.cxx
|
|
//
|
|
// Contents: Helper class for PROPVARIANTs, OLE-DB variant types and
|
|
// Automation variant types in tables
|
|
//
|
|
// Classes: COLEDBVariant - derives from CTableVariant
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 09 Jan 1998 VikasMan Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.cxx"
|
|
#pragma hdrstop
|
|
|
|
#include <bigtable.hxx>
|
|
#include <odbvarnt.hxx>
|
|
|
|
#include <initguid.h>
|
|
#define DBINITCONSTANTS
|
|
#include <msdadc.h> // oledb data conversion (IDataConvert) interface
|
|
#include <msdaguid.h>
|
|
|
|
#include "tabledbg.hxx"
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: COLEDBVariant::OLEDBConvert, public.
|
|
//
|
|
// Synopsis: Data conversion routine, which uses the OLEDB data
|
|
// conversion library (MSDADC.DLL) to do the conversion.
|
|
//
|
|
// Arguments: [pbDstBuf] -- the Destination data buffer
|
|
// [cbDstBuf] -- the size of Dst. buffer
|
|
// [vtDst] -- the Destination type.
|
|
// [rPool] -- pool to use for destination buffers
|
|
// [rcbDstLength] -- size of destination data
|
|
// [xDataConvert] -- the OLEDB IDataConvert interface
|
|
// [bPrecision] -- The precision of the output data in bytes,
|
|
// if applicable. This argument is used when
|
|
// converting to DBTYPE_NUMERIC data only.
|
|
// [bScale] -- The scale of the output data in bytes,
|
|
// if applicable. This argument is used when
|
|
// converting to DBTYPE_NUMERIC data only.
|
|
//
|
|
// Returns: DBSTATUS_S_OK if conversion is successful,
|
|
// else other DBSTATUS values.
|
|
//
|
|
// Notes: pbDstBuf should have (enough) memory allocated, else
|
|
// truncation can happen.
|
|
//
|
|
// This routine is subdivided into 3 parts:
|
|
// - It checks first if we are dealing with Automation Vars.
|
|
// - Then it calls CTableVaraint::CopyOrCoerce to the job
|
|
// - If unsuccessful, it uses the OLE-DB library
|
|
//
|
|
// History: 09 Jan 1998 VikasMan Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::OLEDBConvert(
|
|
BYTE * pbDstBuf,
|
|
DBLENGTH cbDstBuf,
|
|
VARTYPE vtDst,
|
|
PVarAllocator & rPool,
|
|
DBLENGTH & rcbDstLength,
|
|
XInterface<IDataConvert>& xDataConvert,
|
|
BOOL fExtTypes, /* = TRUE */
|
|
BYTE bPrecision, /* = 0 */
|
|
BYTE bScale /* = 0 */ ) const
|
|
{
|
|
void* pbSrcBuf;
|
|
ULONG cbSrcSize;
|
|
DBTYPE dbtypeSrc, dbtypeDst;
|
|
DBLENGTH cbDstBufNeeded;
|
|
DBSTATUS DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
|
|
|
|
// Check if fExtTypes is false and we are dealing with automation variants
|
|
if ( VT_VARIANT == vtDst || DBTYPE_PROPVARIANT == vtDst )
|
|
{
|
|
Win4Assert(cbDstBuf == sizeof PROPVARIANT);
|
|
|
|
rcbDstLength = sizeof (PROPVARIANT);
|
|
if ( ! IsArray( vt) &&
|
|
( fExtTypes || DBTYPE_PROPVARIANT == vtDst ||
|
|
VT_BSTR == vt || (IsSimpleOAType( vt ) && ! IsVector( vt )) ) )
|
|
{
|
|
Copy( (CTableVariant*) pbDstBuf, rPool, (USHORT) VarDataSize() );
|
|
DstStatus = DBSTATUS_S_OK;
|
|
}
|
|
else
|
|
{
|
|
DstStatus = _CopyToOAVariant( (VARIANT *) pbDstBuf, rPool );
|
|
}
|
|
|
|
if ( VT_EMPTY == vt )
|
|
DstStatus = DBSTATUS_S_ISNULL;
|
|
}
|
|
else
|
|
{
|
|
// try converting using CTableVariant's CopyOrCoerce
|
|
DstStatus = CopyOrCoerce( pbDstBuf,
|
|
cbDstBuf,
|
|
vtDst,
|
|
rcbDstLength,
|
|
rPool );
|
|
}
|
|
|
|
if ( DBStatusOK( DstStatus ))
|
|
{
|
|
// we are done here
|
|
return DstStatus;
|
|
}
|
|
|
|
if (DBTYPE_HCHAPTER == vtDst)
|
|
{
|
|
if (VT_I4 == vt || VT_UI4 == vt)
|
|
{
|
|
* (ULONG *) pbDstBuf = lVal;
|
|
DstStatus = DBSTATUS_S_OK;
|
|
}
|
|
|
|
return DstStatus;
|
|
}
|
|
|
|
// WORKAROUND: The following switch stmt is needed only until
|
|
// OLEDB library supports VT_FILETIME. Once it does that,
|
|
// we can get rid of this.
|
|
|
|
switch ( vtDst )
|
|
{
|
|
case VT_DATE:
|
|
// allow coercions from I8, UI8, R8, and FILETIME
|
|
|
|
if (VT_I8 == vt || VT_UI8 == vt)
|
|
{
|
|
* (LONGLONG *) pbDstBuf = hVal.QuadPart;
|
|
}
|
|
else if (VT_R8 == vt)
|
|
{
|
|
* (DATE *) pbDstBuf = dblVal;
|
|
}
|
|
else
|
|
{
|
|
DstStatus = _StoreDate(pbDstBuf, cbDstBuf, vtDst);
|
|
}
|
|
rcbDstLength = sizeof (DATE);
|
|
break;
|
|
|
|
case VT_FILETIME:
|
|
// allow coercions from I8, UI8, and DATE
|
|
|
|
if (VT_I8 == vt || VT_UI8 == vt)
|
|
{
|
|
* (LONGLONG *) pbDstBuf = hVal.QuadPart;
|
|
}
|
|
else
|
|
{
|
|
DstStatus = _StoreDate(pbDstBuf, cbDstBuf, vtDst);
|
|
}
|
|
rcbDstLength = sizeof (FILETIME);
|
|
break;
|
|
|
|
case DBTYPE_DBDATE:
|
|
DstStatus = _StoreDate(pbDstBuf, cbDstBuf, vtDst);
|
|
rcbDstLength = sizeof (DBDATE);
|
|
break;
|
|
|
|
case DBTYPE_DBTIME:
|
|
DstStatus = _StoreDate(pbDstBuf, cbDstBuf, vtDst);
|
|
rcbDstLength = sizeof (DBTIME);
|
|
break;
|
|
|
|
case DBTYPE_DBTIMESTAMP:
|
|
DstStatus = _StoreDate(pbDstBuf, cbDstBuf, vtDst);
|
|
rcbDstLength = sizeof (DBTIMESTAMP);
|
|
break;
|
|
}
|
|
|
|
if ( DBStatusOK( DstStatus ))
|
|
{
|
|
// we are done here
|
|
return DstStatus;
|
|
}
|
|
|
|
tbDebugOut(( DEB_ITRACE, "COLEDBVaraint::OLEDBConvert - Using OLEDB library for conversion\n" ));
|
|
|
|
// this looks like a job for ole-db
|
|
|
|
// check if we have the IDataConvert interface
|
|
if ( xDataConvert.IsNull( ) )
|
|
{
|
|
// let's get it then
|
|
if ( !_GetIDataConvert( xDataConvert ) )
|
|
{
|
|
// for some reason we could not get the IDataConvert interface
|
|
return DBSTATUS_E_CANTCONVERTVALUE;
|
|
}
|
|
}
|
|
|
|
// get the source data pointer
|
|
pbSrcBuf = _GetDataPointer();
|
|
if ( 0 == pbSrcBuf )
|
|
{
|
|
tbDebugOut(( DEB_ERROR, "OLEDBConvert - _GetDataPointer returned NULL\n" ));
|
|
|
|
return DBSTATUS_E_CANTCONVERTVALUE;
|
|
}
|
|
|
|
// get the source data size
|
|
cbSrcSize = VarDataSize();
|
|
|
|
// get the OLEDB source type
|
|
SCODE sc = _GetOLEDBType( vt, dbtypeSrc );
|
|
if ( S_OK != sc )
|
|
{
|
|
// can't use the OLEDB Conversion library
|
|
tbDebugOut(( DEB_ERROR,
|
|
"OLEDBConvert - _GetOLEDBType returned error 0x%x for type %x\n",
|
|
sc, vt ));
|
|
return DBSTATUS_E_CANTCONVERTVALUE;
|
|
}
|
|
|
|
|
|
// the destination type has to be an OLE-DB type
|
|
dbtypeDst = vtDst;
|
|
|
|
// get the needed Destination size
|
|
sc = xDataConvert->GetConversionSize( dbtypeSrc,
|
|
dbtypeDst,
|
|
0,
|
|
&cbDstBufNeeded,
|
|
pbSrcBuf );
|
|
|
|
if ( sc != S_OK )
|
|
{
|
|
tbDebugOut(( DEB_ITRACE,
|
|
"OLEDBConvert - GetConversionSize returned error 0x%x\n",
|
|
sc ));
|
|
return DBSTATUS_E_CANTCONVERTVALUE;
|
|
}
|
|
|
|
BYTE* pbDest = 0;
|
|
|
|
// we need to allocate memory if ...
|
|
|
|
if ( ( IsLPWSTR( dbtypeDst ) ) ||
|
|
( IsLPSTR( dbtypeDst ) ) ||
|
|
( (DBTYPE_BYREF | DBTYPE_WSTR) == dbtypeDst ) ||
|
|
( (DBTYPE_BYREF | DBTYPE_STR) == dbtypeDst )
|
|
)
|
|
{
|
|
// If we hit this assert, then we got a few things to think about
|
|
|
|
Win4Assert( !(IsLPWSTR( dbtypeDst ) || IsLPSTR( dbtypeDst )) );
|
|
|
|
pbDest = (BYTE*) rPool.Allocate( (ULONG) cbDstBufNeeded );
|
|
}
|
|
else if ( DBTYPE_BSTR == dbtypeDst )
|
|
{
|
|
pbDest = (BYTE*) rPool.AllocBSTR( (ULONG) cbDstBufNeeded );
|
|
}
|
|
else
|
|
{
|
|
// bogus assert
|
|
// Win4Assert ( (dbtypeDst & DBTYPE_BYREF) == 0 );
|
|
|
|
// memory is already allocated
|
|
// use the size which is less
|
|
// if cbDstBuf is less than cbDstBufNeeded, truncation might happen
|
|
cbDstBufNeeded = ( cbDstBufNeeded < cbDstBuf ? cbDstBufNeeded : cbDstBuf );
|
|
}
|
|
|
|
// do the conversion
|
|
sc = xDataConvert->DataConvert( dbtypeSrc,
|
|
dbtypeDst,
|
|
cbSrcSize,
|
|
&rcbDstLength,
|
|
pbSrcBuf,
|
|
pbDest ? (void*)&pbDest : pbDstBuf,
|
|
cbDstBufNeeded,
|
|
DstStatus,
|
|
&DstStatus,
|
|
bPrecision,
|
|
bScale,
|
|
DBDATACONVERT_DEFAULT);
|
|
|
|
if ( sc != S_OK )
|
|
{
|
|
tbDebugOut(( DEB_ITRACE,
|
|
"OLEDBConvert - DataConvert returned error 0x%x\n",
|
|
sc ));
|
|
return DBSTATUS_E_CANTCONVERTVALUE;
|
|
}
|
|
|
|
// if memory was allocated, put that ptr in pbDstBuf
|
|
if ( pbDest )
|
|
{
|
|
*((BYTE**)(pbDstBuf)) = pbDest;
|
|
}
|
|
|
|
return DstStatus;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: COLEDBVariant::GetDstLength, public.
|
|
//
|
|
// Synopsis: Returns the length required after the conversion without
|
|
// actually doing the conversion.
|
|
//
|
|
// History: 10-12-98 DanLeg Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::GetDstLength(
|
|
XInterface<IDataConvert>& xDataConvert,
|
|
DBTYPE dbtypeDst,
|
|
DBLENGTH & rcbDstLen )
|
|
{
|
|
SCODE sc = S_OK;
|
|
DBTYPE dbtypeSrc;
|
|
DBSTATUS DstStatus = DBSTATUS_S_OK;
|
|
|
|
sc = _GetOLEDBType( vt, dbtypeSrc );
|
|
|
|
if ( S_OK == sc )
|
|
{
|
|
if ( xDataConvert.IsNull( ) )
|
|
{
|
|
if ( !_GetIDataConvert( xDataConvert ) )
|
|
sc = S_FALSE;
|
|
}
|
|
|
|
if ( S_OK == sc )
|
|
{
|
|
void * pbSrcBuf = _GetDataPointer();
|
|
sc = xDataConvert->GetConversionSize( dbtypeSrc,
|
|
dbtypeDst,
|
|
0,
|
|
&rcbDstLen,
|
|
pbSrcBuf );
|
|
}
|
|
}
|
|
|
|
if ( S_OK != sc )
|
|
{
|
|
tbDebugOut(( DEB_ITRACE,
|
|
"OLEDBConvert - GetConversionSize returned error 0x%x\n",
|
|
sc ));
|
|
DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
|
|
}
|
|
|
|
return DstStatus;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: COLEDBVariant::_GetOLEDBType, private.
|
|
//
|
|
// Synopsis: Returns the OLEDB type equivalent of Variant type.
|
|
//
|
|
// Arguments: [vt] -- the source varaint type.
|
|
// [dbtype] -- the equivalent oledb type.
|
|
//
|
|
// Returns: S_OK if equivalent OLE DB type exists,
|
|
// else S_FALSE.
|
|
//
|
|
// Notes: Does not handle vectors
|
|
//
|
|
// History: 09 Jan 1998 VikasMan Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
inline SCODE COLEDBVariant::_GetOLEDBType( VARTYPE vt, DBTYPE& dbtype ) const
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
switch ( vt & ~VT_BYREF )
|
|
{
|
|
case VT_I1:
|
|
case VT_UI1:
|
|
case VT_I2:
|
|
case VT_UI2:
|
|
case VT_I4:
|
|
case VT_UI4:
|
|
case VT_I8:
|
|
case VT_UI8:
|
|
case VT_R4:
|
|
case VT_R8:
|
|
case VT_CY:
|
|
case VT_DATE:
|
|
case VT_BSTR:
|
|
case VT_FILETIME: // WORKAROUND: Waiting on OLE DB Conv lib to handle this case - 01.12.98
|
|
case VT_BOOL:
|
|
case VT_ERROR:
|
|
case VT_CLSID:
|
|
case VT_VARIANT:
|
|
case VT_DECIMAL:
|
|
|
|
case VT_VECTOR | VT_I1:
|
|
case VT_VECTOR | VT_UI1:
|
|
case VT_VECTOR | VT_I2:
|
|
case VT_VECTOR | VT_UI2:
|
|
case VT_VECTOR | VT_I4:
|
|
case VT_VECTOR | VT_UI4:
|
|
case VT_VECTOR | VT_I8:
|
|
case VT_VECTOR | VT_UI8:
|
|
case VT_VECTOR | VT_R4:
|
|
case VT_VECTOR | VT_R8:
|
|
case VT_VECTOR | VT_CY:
|
|
case VT_VECTOR | VT_DATE:
|
|
case VT_VECTOR | VT_BSTR:
|
|
case VT_VECTOR | VT_FILETIME: // WORKAROUND: Waiting on OLE DB Conv lib to handle this case - 01.12.98
|
|
case VT_VECTOR | VT_BOOL:
|
|
case VT_VECTOR | VT_ERROR:
|
|
case VT_VECTOR | VT_CLSID:
|
|
case VT_VECTOR | VT_VARIANT:
|
|
|
|
case VT_ARRAY | VT_I1:
|
|
case VT_ARRAY | VT_UI1:
|
|
case VT_ARRAY | VT_I2:
|
|
case VT_ARRAY | VT_UI2:
|
|
case VT_ARRAY | VT_I4:
|
|
case VT_ARRAY | VT_UI4:
|
|
case VT_ARRAY | VT_I8:
|
|
case VT_ARRAY | VT_UI8:
|
|
case VT_ARRAY | VT_R4:
|
|
case VT_ARRAY | VT_R8:
|
|
case VT_ARRAY | VT_CY:
|
|
case VT_ARRAY | VT_DATE:
|
|
case VT_ARRAY | VT_BSTR:
|
|
case VT_ARRAY | VT_BOOL:
|
|
case VT_ARRAY | VT_VARIANT:
|
|
case VT_ARRAY | VT_DECIMAL:
|
|
|
|
// In all the above cases, the DBTYPE has same value as
|
|
// VARIANT type
|
|
case DBTYPE_NUMERIC:
|
|
case DBTYPE_DBDATE:
|
|
case DBTYPE_DBTIME:
|
|
case DBTYPE_DBTIMESTAMP:
|
|
case DBTYPE_HCHAPTER:
|
|
case DBTYPE_BYTES:
|
|
case DBTYPE_VARNUMERIC:
|
|
// The above are OLEDB types only. So no conversion needed.
|
|
dbtype = vt;
|
|
break;
|
|
|
|
case VT_LPSTR:
|
|
case DBTYPE_STR:
|
|
dbtype = DBTYPE_STR;
|
|
break;
|
|
|
|
case VT_LPWSTR:
|
|
case DBTYPE_WSTR:
|
|
dbtype = DBTYPE_WSTR;
|
|
break;
|
|
|
|
case VT_BLOB:
|
|
dbtype = VT_VECTOR | VT_UI1;
|
|
break;
|
|
|
|
case VT_INT:
|
|
dbtype = VT_I4;
|
|
break;
|
|
|
|
case VT_UINT:
|
|
dbtype = VT_UI4;
|
|
break;
|
|
|
|
case VT_ARRAY | VT_INT:
|
|
dbtype = VT_ARRAY | VT_I4;
|
|
break;
|
|
|
|
case VT_ARRAY | VT_UINT:
|
|
dbtype = VT_ARRAY | VT_UI4;
|
|
break;
|
|
|
|
// SPECDEVIATION: What about VT_CF ??? (handled partially in base class)
|
|
|
|
default:
|
|
// default case: all types for which there is no equivalent
|
|
// OLE DB type - VT_CF, VT_BLOBOBJECT,
|
|
// VT_STREAM, VT_STREAMED_OBJECT, VT_STORAGE, VT_STORED_OBJECT,
|
|
// VT_DISPATCH, VT_UNKNOWN,
|
|
sc = S_FALSE;
|
|
break;
|
|
}
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_GetDataPointer, private
|
|
//
|
|
// Synopsis: Depending on the type of vt, returns the data pointer
|
|
//
|
|
// Arguments: -none-
|
|
//
|
|
// Returns: Returns the pointer to data in the PropVariant
|
|
//
|
|
// History: 09 Jan 1998 VikasMan Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void* COLEDBVariant::_GetDataPointer() const
|
|
{
|
|
if (vt & VT_VECTOR)
|
|
return (void*)&cal;
|
|
|
|
if (vt & VT_ARRAY)
|
|
return (void*) parray;
|
|
|
|
void* pDataPtr = 0;
|
|
|
|
switch ( vt )
|
|
{
|
|
case VT_LPSTR:
|
|
case VT_LPWSTR:
|
|
case VT_CLSID:
|
|
case VT_CF:
|
|
// all pointer values
|
|
pDataPtr = (void*) pszVal;
|
|
break;
|
|
|
|
case VT_BSTR:
|
|
// need address of bstr ptr
|
|
pDataPtr = (void*) &bstrVal;
|
|
break;
|
|
|
|
case VT_BLOB:
|
|
case VT_BLOB_OBJECT:
|
|
pDataPtr = (void*) &blob;
|
|
break;
|
|
|
|
case VT_DECIMAL:
|
|
pDataPtr = (void*) this;
|
|
break;
|
|
|
|
// cases which we do not handle
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
case VT_ILLEGAL:
|
|
case VT_STREAM:
|
|
case VT_STREAMED_OBJECT:
|
|
case VT_STORAGE:
|
|
case VT_STORED_OBJECT:
|
|
case VT_DISPATCH:
|
|
case VT_VARIANT:
|
|
case VT_UNKNOWN:
|
|
case VT_VOID:
|
|
pDataPtr = 0;
|
|
break;
|
|
|
|
// Rest of the stuff
|
|
default:
|
|
pDataPtr = (void*) &bVal;
|
|
break;
|
|
}
|
|
|
|
return pDataPtr;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_CopyToOAVariant, private
|
|
//
|
|
// Synopsis: Copy table data between a table variant structure and
|
|
// an Ole automation variant. Automation variants have a
|
|
// restricted set of usable types and vectors must be converted
|
|
// to safearrays.
|
|
//
|
|
// Arguments: [pDest] -- pointer to destination variant
|
|
// [rPool] -- pool to use for destination buffers
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// History: 09 Jan 1998 VikasMan Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_CopyToOAVariant( VARIANT * pDest,
|
|
PVarAllocator & rPool) const
|
|
{
|
|
DBSTATUS DstStatus = DBSTATUS_S_OK;
|
|
|
|
switch (vt)
|
|
{
|
|
case VT_LPSTR:
|
|
case VT_LPWSTR:
|
|
{
|
|
DBLENGTH ulTemp;
|
|
pDest->vt = VT_BSTR;
|
|
DstStatus = _StoreString( (BYTE *)&(pDest->bstrVal),
|
|
sizeof (BSTR),
|
|
VT_BSTR,
|
|
ulTemp,
|
|
rPool);
|
|
break;
|
|
}
|
|
|
|
case VT_I8:
|
|
case VT_UI8:
|
|
DstStatus = _StoreDecimal( &(pDest->decVal) );
|
|
pDest->vt = VT_DECIMAL;
|
|
break;
|
|
|
|
case VT_I1:
|
|
DstStatus = _StoreIntegerSignedToUnSigned( VT_UI1, &(pDest->bVal) );
|
|
pDest->vt = VT_UI1;
|
|
break;
|
|
|
|
case VT_UI2:
|
|
if (uiVal <= SHRT_MAX)
|
|
{
|
|
DstStatus = _StoreIntegerUnSignedToSigned( VT_I2, (BYTE*)&(pDest->iVal) );
|
|
pDest->vt = VT_I2;
|
|
}
|
|
else
|
|
{
|
|
DstStatus = _StoreIntegerUnSignedToSigned( VT_I4, (BYTE*)&(pDest->lVal) );
|
|
pDest->vt = VT_I4;
|
|
}
|
|
break;
|
|
|
|
case VT_UI4:
|
|
if (ulVal <= LONG_MAX)
|
|
{
|
|
DstStatus = _StoreIntegerUnSignedToSigned( VT_I4, (BYTE*)&(pDest->lVal) );
|
|
pDest->vt = VT_I4;
|
|
}
|
|
else
|
|
{
|
|
DstStatus = _StoreDecimal( &(pDest->decVal) );
|
|
pDest->vt = VT_DECIMAL;
|
|
}
|
|
break;
|
|
|
|
case VT_FILETIME:
|
|
DstStatus = _StoreDate( (BYTE*)&(pDest->date),
|
|
sizeof pDest->date,
|
|
VT_DATE );
|
|
pDest->vt = VT_DATE;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_I2):
|
|
case (VT_VECTOR | VT_I4):
|
|
case (VT_VECTOR | VT_R4):
|
|
case (VT_VECTOR | VT_R8):
|
|
case (VT_VECTOR | VT_CY):
|
|
case (VT_VECTOR | VT_DATE):
|
|
case (VT_VECTOR | VT_ERROR):
|
|
case (VT_VECTOR | VT_BOOL):
|
|
case (VT_VECTOR | VT_UI1):
|
|
case (VT_VECTOR | VT_DECIMAL):
|
|
Win4Assert( IsSimpleOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreSimpleTypeArray( &(pDest->parray));
|
|
pDest->vt = (vt & VT_TYPEMASK) | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_UI4): // could step thru to see if I4 is big enough
|
|
case (VT_VECTOR | VT_I8):
|
|
case (VT_VECTOR | VT_UI8):
|
|
Win4Assert( !IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreDecimalArray( &(pDest->parray));
|
|
pDest->vt = VT_DECIMAL | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_UI2): // could step thru to detect if I2 is big enough
|
|
Win4Assert( !IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreIntegerArray( VT_I4, &(pDest->parray));
|
|
pDest->vt = VT_I4 | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_I1): // should step thru to detect if UI1 is big enough
|
|
Win4Assert( !IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreIntegerArray( VT_UI1, &(pDest->parray));
|
|
pDest->vt = VT_UI1 | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_LPSTR): // byref/vector mutually exclusive
|
|
Win4Assert( !IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreLPSTRArray( &(pDest->parray), rPool );
|
|
pDest->vt = VT_BSTR | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_LPWSTR):
|
|
Win4Assert( !IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreLPWSTRArray( &(pDest->parray), rPool );
|
|
pDest->vt = VT_BSTR | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_BSTR):
|
|
Win4Assert( IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreBSTRArray( &(pDest->parray), rPool );
|
|
pDest->vt = VT_BSTR | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_VARIANT):
|
|
Win4Assert( IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreVariantArray( &(pDest->parray), rPool );
|
|
pDest->vt = VT_VARIANT | VT_ARRAY;
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_FILETIME):
|
|
Win4Assert( !IsOAType(vt & VT_TYPEMASK));
|
|
Win4Assert( CanBeVectorType(vt & VT_TYPEMASK));
|
|
DstStatus = _StoreDateArray( &(pDest->parray) );
|
|
pDest->vt = VT_DATE | VT_ARRAY;
|
|
break;
|
|
|
|
case VT_ARRAY | VT_I1:
|
|
case VT_ARRAY | VT_UI1:
|
|
case VT_ARRAY | VT_I2:
|
|
case VT_ARRAY | VT_UI2:
|
|
case VT_ARRAY | VT_I4:
|
|
case VT_ARRAY | VT_INT:
|
|
case VT_ARRAY | VT_UI4:
|
|
case VT_ARRAY | VT_UINT:
|
|
case VT_ARRAY | VT_ERROR:
|
|
case VT_ARRAY | VT_I8:
|
|
case VT_ARRAY | VT_UI8:
|
|
case VT_ARRAY | VT_R4:
|
|
case VT_ARRAY | VT_R8:
|
|
case VT_ARRAY | VT_CY:
|
|
case VT_ARRAY | VT_DATE:
|
|
case VT_ARRAY | VT_BSTR:
|
|
case VT_ARRAY | VT_BOOL:
|
|
case VT_ARRAY | VT_VARIANT:
|
|
case VT_ARRAY | VT_DECIMAL:
|
|
{
|
|
SAFEARRAY * psa = 0;
|
|
SCODE sc = SafeArrayCopy( parray, &psa );
|
|
Win4Assert( E_INVALIDARG != sc );
|
|
Win4Assert( E_OUTOFMEMORY == sc || psa != 0 );
|
|
if (S_OK != sc)
|
|
{
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
}
|
|
else
|
|
{
|
|
pDest->vt = vt;
|
|
pDest->parray = psa;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case VT_CLSID: // no equivalent in OA variant
|
|
case VT_CF: // no equivalent in OA variant
|
|
default:
|
|
Win4Assert( !(VT_ARRAY & vt) ); // should be handled elsewhere
|
|
Win4Assert( !IsOAType(vt) ); // should be handled elsewhere
|
|
Win4Assert(CanBeVectorType(vt & VT_TYPEMASK) || !(VT_VECTOR & vt));
|
|
tbDebugOut(( DEB_WARN, "COLEDBVariant::CopyToOAVariant - bad variant type %d \n", vt ));
|
|
|
|
DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
|
|
}
|
|
|
|
if ( !StatusSuccess(DstStatus) ||
|
|
(DBSTATUS_S_ISNULL == DstStatus && pDest->vt != VT_NULL) )
|
|
pDest->vt = VT_EMPTY;
|
|
|
|
return DstStatus;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreSimpleTypeArray, private
|
|
//
|
|
// Synopsis: Copy vector of simple OA types to safearray of same type
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// Notes: None of the simple types require memory allocation.
|
|
// Throws if safearray itself cannot be alloc'd
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreSimpleTypeArray(SAFEARRAY ** pbDstBuf) const
|
|
{
|
|
if ( 0 == caul.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
SAFEARRAY *sa = SafeArrayCreateVector(vt & VT_TYPEMASK, 0, caul.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
XSafeArray xsa(sa);
|
|
|
|
USHORT cbSize, cbAlign, rgFlags;
|
|
VartypeInfo(vt & VT_TYPEMASK, cbSize, cbAlign, rgFlags);
|
|
BYTE * pBase = (BYTE *)&(caul.pElems[0]);
|
|
for (LONG lElem = 0; lElem < (LONG)(caul.cElems); lElem++)
|
|
{
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, pBase + (cbSize * lElem));
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
|
|
*pbDstBuf = xsa.Acquire();
|
|
|
|
return DBSTATUS_S_OK;
|
|
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreDecimalArray, private
|
|
//
|
|
// Synopsis: Copy vector to decimal safearray
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// Notes: Expects the 'this' data type to be VT_UI4|VT_VECTOR,
|
|
// VT_I8|VT_VECTOR, or VT_UI8|VT_VECTOR.
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreDecimalArray( SAFEARRAY ** pbDstBuf ) const
|
|
{
|
|
if ( 0 == caul.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
DBSTATUS dbStatus = DBSTATUS_S_OK; // status of last conversion
|
|
DBSTATUS dbStatusRet = DBSTATUS_S_OK; // error code of last conversion,
|
|
// or if no errors, DBSTATUS_S code
|
|
// of last item with any trouble converting.
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
SAFEARRAY * sa = SafeArrayCreateVector(VT_DECIMAL, 0, caul.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
XSafeArray xsa(sa);
|
|
|
|
for (LONG lElem = 0; lElem < (LONG)caul.cElems && StatusSuccess(dbStatus); lElem++)
|
|
{
|
|
DECIMAL dec;
|
|
dbStatus = _StoreDecimal( &dec, lElem);
|
|
if (DBSTATUS_S_OK != dbStatus)
|
|
dbStatusRet = dbStatus; // save last non-zero status
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, &dec);
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
if (StatusSuccess(dbStatus))
|
|
{
|
|
*pbDstBuf = xsa.Acquire();
|
|
}
|
|
return dbStatusRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreIntegerArray, private
|
|
//
|
|
// Synopsis: Copy vector of integers to safearray of integers
|
|
//
|
|
// Arguments: [vtDst] -- destination safearray type
|
|
// [pbDstBuf] -- destination buffer
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// Notes: Expects the 'this' data type to be an int type | VT_VECTOR.
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
DBSTATUS COLEDBVariant::_StoreIntegerArray(VARTYPE vtDst,
|
|
SAFEARRAY ** pbDstBuf) const
|
|
{
|
|
if ( 0 == caul.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
DBSTATUS dbStatus = DBSTATUS_S_OK;
|
|
DBSTATUS dbStatusRet = DBSTATUS_S_OK; // error code of last conversion,
|
|
// or if no errors, DBSTATUS_S code
|
|
// of last item with any trouble converting.
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
SAFEARRAY * sa = SafeArrayCreateVector(vtDst, 0, caul.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
XSafeArray xsa(sa);
|
|
|
|
for (LONG lElem = 0; lElem < (LONG)caul.cElems && StatusSuccess(dbStatus); lElem++)
|
|
{
|
|
LONGLONG iInt; // size of longest int - to use as buffer
|
|
dbStatus = _StoreInteger( vtDst, (BYTE *)&iInt, lElem);
|
|
if (DBSTATUS_S_OK != dbStatus)
|
|
dbStatusRet = dbStatus; // save last non-zero status
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, &iInt);
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
if (StatusSuccess(dbStatus))
|
|
{
|
|
*pbDstBuf = xsa.Acquire();
|
|
}
|
|
return dbStatusRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreLPSTRArray, private
|
|
//
|
|
// Synopsis: Copy LPSTR vector to safearray
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
// [rPool] -- pool to use for destination buffers
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreLPSTRArray(
|
|
SAFEARRAY ** pbDstBuf,
|
|
PVarAllocator & rPool) const
|
|
{
|
|
if ( 0 == calpstr.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
DBSTATUS dbStatus = DBSTATUS_S_OK;
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
|
|
SAFEARRAY * sa = SafeArrayCreateVector(VT_BSTR, 0, calpstr.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
|
|
XSafeArray xsa(sa);
|
|
|
|
for (LONG lElem = 0; lElem < (LONG)(calpstr).cElems && StatusSuccess(dbStatus); lElem++)
|
|
{
|
|
int cwc = MultiByteToWideChar(ulCoercionCodePage,0,
|
|
calpstr.pElems[lElem],-1,0,0);
|
|
if (0 == cwc)
|
|
{
|
|
dbStatus = DBSTATUS_E_CANTCONVERTVALUE; // something odd...
|
|
}
|
|
else
|
|
{
|
|
XArray<WCHAR> wcsDest( cwc );
|
|
MultiByteToWideChar(ulCoercionCodePage, 0,
|
|
calpstr.pElems[lElem], -1, wcsDest.Get(), cwc);
|
|
|
|
BSTR bstrDest = (BSTR) rPool.CopyBSTR((cwc-1)*sizeof (OLECHAR),
|
|
wcsDest.Get());
|
|
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, (void *)rPool.PointerToOffset(bstrDest));
|
|
rPool.FreeBSTR(bstrDest);
|
|
|
|
if (E_OUTOFMEMORY == sc)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
}
|
|
|
|
if (StatusSuccess(dbStatus))
|
|
{
|
|
*pbDstBuf = xsa.Acquire();
|
|
}
|
|
|
|
|
|
return dbStatus;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreLPWSTRArray, private
|
|
//
|
|
// Synopsis: Copy LPWSTR vector to safearray
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
// [rPool] -- pool to use for destination buffers
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreLPWSTRArray(
|
|
SAFEARRAY ** pbDstBuf,
|
|
PVarAllocator & rPool) const
|
|
{
|
|
if ( 0 == calpwstr.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
SAFEARRAY * sa = SafeArrayCreateVector(VT_BSTR, 0, calpwstr.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
|
|
XSafeArray xsa(sa);
|
|
|
|
for (LONG lElem = 0; lElem < (LONG)(calpwstr.cElems); lElem++)
|
|
{
|
|
BSTR bstrDest = (BSTR) rPool.CopyBSTR( wcslen(calpwstr.pElems[lElem]) * sizeof(WCHAR),
|
|
calpwstr.pElems[lElem] );
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, (void *)rPool.PointerToOffset(bstrDest));
|
|
rPool.FreeBSTR(bstrDest);
|
|
|
|
if (E_OUTOFMEMORY == sc)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
|
|
*pbDstBuf = xsa.Acquire();
|
|
return DBSTATUS_S_OK;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreBSTRArray, private
|
|
//
|
|
// Synopsis: Copy BSTR vector to safearray
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
// [rPool] -- pool to use for destination buffers
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// Notes: Expects the 'this' data type to be VT_BSTR | VT_VECTOR.
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreBSTRArray(
|
|
SAFEARRAY ** pbDstBuf,
|
|
PVarAllocator & rPool) const
|
|
{
|
|
if ( 0 == cabstr.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
SAFEARRAY * sa = SafeArrayCreateVector(VT_BSTR, 0, cabstr.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
|
|
XSafeArray xsa(sa);
|
|
|
|
for (LONG lElem = 0; lElem < (LONG)cabstr.cElems; lElem++)
|
|
{
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, cabstr.pElems[lElem]);
|
|
if (E_OUTOFMEMORY == sc)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
|
|
*pbDstBuf = xsa.Acquire();
|
|
|
|
return DBSTATUS_S_OK;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreVariantArray, private
|
|
//
|
|
// Synopsis: Copy variant vector to safearray
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
// [rPool] -- pool to use for destination buffers
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// Notes: Expects the 'this' data type to be VT_VARIANT | VT_VECTOR.
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreVariantArray(
|
|
SAFEARRAY ** pbDstBuf,
|
|
PVarAllocator & rPool) const
|
|
{
|
|
if ( 0 == capropvar.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
DBSTATUS dbStatus = DBSTATUS_S_OK;
|
|
DBSTATUS dbStatusRet = DBSTATUS_S_OK; // error code of last conversion,
|
|
// or if no errors, DBSTATUS_S code
|
|
// of last item with any trouble converting.
|
|
|
|
Win4Assert(vt == (VT_VECTOR | VT_VARIANT));
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
SAFEARRAY * sa = SafeArrayCreateVector(VT_VARIANT, 0, capropvar.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
XSafeArray xsa(sa);
|
|
|
|
for (LONG lElem = 0; lElem < (LONG)(capropvar.cElems) && StatusSuccess(dbStatus); lElem++)
|
|
{
|
|
COLEDBVariant tblVariant;
|
|
if (IsOAType(capropvar.pElems[lElem].vt))
|
|
{
|
|
((CTableVariant &)capropvar.pElems[lElem]).Copy(&tblVariant,
|
|
rPool,
|
|
(USHORT)((CTableVariant &)capropvar.pElems[lElem]).VarDataSize(),
|
|
0);
|
|
}
|
|
else // convert variant to an OA type
|
|
{
|
|
dbStatus = ((COLEDBVariant &)capropvar.pElems[lElem])._CopyToOAVariant( (VARIANT *)&tblVariant, rPool);
|
|
if (DBSTATUS_S_OK != dbStatus)
|
|
dbStatusRet = dbStatus; // save last non-zero status
|
|
|
|
}
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, (PROPVARIANT *)&tblVariant);
|
|
if (E_OUTOFMEMORY == sc)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
|
|
*pbDstBuf = xsa.Acquire();
|
|
return dbStatusRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreDateArray, private
|
|
//
|
|
// Synopsis: Copy date vector to safearray of dates
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// Notes: Expects the 'this' data type to be VT_DATE | VT_VECTOR.
|
|
//
|
|
// History: 09 Apr 1997 EmilyB Created
|
|
// 09 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreDateArray(SAFEARRAY ** pbDstBuf) const
|
|
{
|
|
if ( 0 == caul.cElems )
|
|
return DBSTATUS_S_ISNULL;
|
|
|
|
DBSTATUS dbStatus = DBSTATUS_S_OK;
|
|
DBSTATUS dbStatusRet = DBSTATUS_S_OK; // error code of last conversion,
|
|
// or if no errors, DBSTATUS_S code
|
|
// of last item with any trouble converting.
|
|
|
|
// CLEANCODE - add to PVarAllocator?
|
|
SAFEARRAY * sa = SafeArrayCreateVector(VT_DATE, 0, caul.cElems);
|
|
if (0 == sa)
|
|
THROW(CException(E_OUTOFMEMORY));
|
|
XSafeArray xsa(sa);
|
|
|
|
|
|
for (LONG lElem = 0; lElem < (LONG)(caul.cElems) && StatusSuccess(dbStatus); lElem++)
|
|
{
|
|
DATE date;
|
|
dbStatus = _StoreDate( (BYTE *)&date, sizeof(date), VT_DATE, lElem);
|
|
if (DBSTATUS_S_OK != dbStatus)
|
|
dbStatusRet = dbStatus; // save last non-zero status
|
|
|
|
SCODE sc = SafeArrayPutElement(xsa.Get(), &lElem, &date);
|
|
Win4Assert ( SUCCEEDED(sc) );
|
|
}
|
|
if (StatusSuccess(dbStatus))
|
|
{
|
|
*pbDstBuf = xsa.Acquire();
|
|
}
|
|
return dbStatusRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_StoreDate, private
|
|
//
|
|
// Synopsis: Copy variant date/time data, coerce if possible
|
|
//
|
|
// Arguments: [pbDstBuf] -- destination buffer
|
|
// [cbDstBuf] -- size of destination buffer
|
|
// [vtDst] -- data type of the dest
|
|
// [lElem] -- element of vector to convert
|
|
//
|
|
// Returns: status for copy
|
|
//
|
|
// Notes: Expects the 'this' data type to be either VT_FILETIME or
|
|
// VT_DATE. Expects the vtDst to be VT_FILETIME, VT_DATE,
|
|
// DBTYPE_DBDATE, DBTYPE_DBTIME or DBTYPE_DBTIMESTAMP.
|
|
//
|
|
// History: 31 Jan 1997 AlanW Created
|
|
// 13 Jan 1998 VikasMan Moved from CTableVariant class
|
|
// to here
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DBSTATUS COLEDBVariant::_StoreDate(
|
|
BYTE * pbDstBuf,
|
|
DBLENGTH cbDstBuf,
|
|
VARTYPE vtDst,
|
|
LONG lElem) const
|
|
{
|
|
DBSTATUS DstStatus = DBSTATUS_S_OK;
|
|
SYSTEMTIME stUTC;
|
|
|
|
//
|
|
// Convert the input date into a common form: GMT SYSTEMTIME.
|
|
//
|
|
if (VT_DATE == vt)
|
|
{
|
|
if (! VariantTimeToSystemTime(date, &stUTC) )
|
|
return DBSTATUS_E_DATAOVERFLOW;
|
|
}
|
|
else if ((VT_DATE|VT_VECTOR)== vt)
|
|
{
|
|
if (! VariantTimeToSystemTime(cadate.pElems[lElem], &stUTC) )
|
|
return DBSTATUS_E_DATAOVERFLOW;
|
|
}
|
|
else if (VT_FILETIME == vt)
|
|
{
|
|
// do not do local time conversion
|
|
if (! FileTimeToSystemTime((LPFILETIME) &hVal.QuadPart, &stUTC) )
|
|
return DBSTATUS_E_DATAOVERFLOW;
|
|
}
|
|
else if ((VT_FILETIME|VT_VECTOR) == vt)
|
|
{
|
|
// do not do local time conversion
|
|
if (! FileTimeToSystemTime(&cafiletime.pElems[lElem], &stUTC) )
|
|
return DBSTATUS_E_DATAOVERFLOW;
|
|
}
|
|
else
|
|
return DBSTATUS_E_CANTCONVERTVALUE;
|
|
|
|
switch (vtDst)
|
|
{
|
|
case VT_DATE:
|
|
DATE dosDate;
|
|
if (! SystemTimeToVariantTime(&stUTC, &dosDate) )
|
|
return DBSTATUS_E_DATAOVERFLOW;
|
|
|
|
Win4Assert( cbDstBuf >= sizeof DATE );
|
|
RtlCopyMemory(pbDstBuf, &dosDate, sizeof DATE);
|
|
break;
|
|
|
|
case VT_FILETIME:
|
|
FILETIME ftUTC;
|
|
if (! SystemTimeToFileTime(&stUTC, &ftUTC) )
|
|
return DBSTATUS_E_DATAOVERFLOW;
|
|
|
|
Win4Assert( cbDstBuf >= sizeof FILETIME );
|
|
RtlCopyMemory(pbDstBuf, &ftUTC, sizeof FILETIME);
|
|
break;
|
|
|
|
case DBTYPE_DBTIMESTAMP:
|
|
{
|
|
// does not use local time
|
|
DBTIMESTAMP dbUTC;
|
|
dbUTC.year = stUTC.wYear;
|
|
dbUTC.month = stUTC.wMonth;
|
|
dbUTC.day = stUTC.wDay;
|
|
dbUTC.hour = stUTC.wHour;
|
|
dbUTC.minute = stUTC.wMinute;
|
|
dbUTC.second = stUTC.wSecond;
|
|
dbUTC.fraction = stUTC.wMilliseconds * 1000000;
|
|
|
|
Win4Assert( cbDstBuf >= sizeof dbUTC );
|
|
RtlCopyMemory(pbDstBuf, &dbUTC, sizeof dbUTC);
|
|
}
|
|
break;
|
|
|
|
case DBTYPE_DBDATE:
|
|
{
|
|
DBDATE dbUTC;
|
|
dbUTC.year = stUTC.wYear;
|
|
dbUTC.month = stUTC.wMonth;
|
|
dbUTC.day = stUTC.wDay;
|
|
|
|
Win4Assert( cbDstBuf >= sizeof dbUTC );
|
|
RtlCopyMemory(pbDstBuf, &dbUTC, sizeof dbUTC);
|
|
}
|
|
break;
|
|
|
|
case DBTYPE_DBTIME:
|
|
{
|
|
DBTIME dbUTC;
|
|
dbUTC.hour = stUTC.wHour;
|
|
dbUTC.minute = stUTC.wMinute;
|
|
dbUTC.second = stUTC.wSecond;
|
|
|
|
Win4Assert( cbDstBuf >= sizeof dbUTC );
|
|
RtlCopyMemory(pbDstBuf, &dbUTC, sizeof dbUTC);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
|
|
tbDebugOut(( DEB_WARN,
|
|
"_StoreDate - Unexpected dest storage type %4x\n",
|
|
vtDst));
|
|
break;
|
|
}
|
|
|
|
return DstStatus;
|
|
} //_StoreDate
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::CanConvertType, static public
|
|
//
|
|
// Synopsis: Indicate whether a type conversion is valid. Uses the OLEDB
|
|
// Data Conversion Library.
|
|
//
|
|
// Arguments: [wFromType] -- source type
|
|
// [wToType] -- destination type
|
|
// [xDataConvert] -- OLEDB IDataConvert interface pointer
|
|
//
|
|
// Returns: TRUE if the conversion is available, FALSE otherwise.
|
|
//
|
|
// History: 13 Jan 98 VikasMan Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL COLEDBVariant::CanConvertType(
|
|
DBTYPE wFromType,
|
|
DBTYPE wToType,
|
|
XInterface<IDataConvert>& xDataConvert)
|
|
{
|
|
if ( xDataConvert.IsNull( ) )
|
|
{
|
|
// use COLEDBVariant's helper function to get the IDataConvert ptr
|
|
if ( !_GetIDataConvert( xDataConvert ) )
|
|
{
|
|
// bail out
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
SCODE sc = xDataConvert->CanConvert( wFromType, wToType );
|
|
if ( sc != S_OK && sc != S_FALSE )
|
|
{
|
|
QUIETTHROW(CException(sc)); // bad type
|
|
}
|
|
|
|
return ( sc == S_OK );
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COLEDBVariant::_GetIDataConvert, static private
|
|
//
|
|
// Synopsis: Gets the IDataConvert interface
|
|
//
|
|
// Arguments: [xDataConvert] -- OLEDB IDataConvert interface pointer
|
|
//
|
|
// Returns: TRUE if the successful, else FALSE
|
|
//
|
|
// Notes: Make sure thet xDataConvert is null before calling this func.
|
|
//
|
|
// History: 13 Jan 98 VikasMan Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline
|
|
BOOL COLEDBVariant::_GetIDataConvert( XInterface<IDataConvert>& xDataConvert )
|
|
{
|
|
Win4Assert( xDataConvert.IsNull( ) );
|
|
|
|
SCODE sc = CoCreateInstance( CLSID_OLEDB_CONVERSIONLIBRARY,
|
|
NULL,
|
|
CLSCTX_SERVER,
|
|
IID_IDataConvert,
|
|
xDataConvert.GetQIPointer( ) );
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
// for some reason we could not get the IDataConvert interface
|
|
tbDebugOut(( DEB_ERROR,
|
|
"_GetIDataConvert - Couldn't get IDataConvert interface %x\n", sc ));
|
|
return FALSE;
|
|
}
|
|
|
|
// Set the OLEDB ver to 2.00
|
|
|
|
XInterface<IDCInfo> xIDCInfo;
|
|
DCINFO rgInfo[] = {{DCINFOTYPE_VERSION, {VT_UI4, 0, 0, 0, 0x0200}}};
|
|
|
|
sc = xDataConvert->QueryInterface( IID_IDCInfo, xIDCInfo.GetQIPointer( ) );
|
|
if ( SUCCEEDED(sc) )
|
|
{
|
|
sc = xIDCInfo->SetInfo( NUMELEM(rgInfo), rgInfo );
|
|
}
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
tbDebugOut(( DEB_ERROR,
|
|
"_GetIDataConvert - Can't set OLEDB ver to 2.0. Error: 0x%x\n",
|
|
sc));
|
|
Win4Assert( ! "Failed to set OLEDB conversion library version!" );
|
|
xDataConvert.Free();
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|