|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 2000.
//
// File: hraccess.cxx
//
// Contents: OLE DB HRow accessor helper class
//
// Classes: CAccessor
// CRowDataAccessor
// CRowDataAccessorByRef
//
// History: 21 Nov 94 dlee Created from AlanW's tblwindo code
//
//--------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <rowset.hxx>
#include <query.hxx>
#include "tabledbg.hxx"
//+-------------------------------------------------------------------------
//
// Member: CAccessorBag::Destroy, private
//
// Synopsis: Removes an accessor from the bag and deletes it
//
// History: 12 Jan 1995 dlee Created
//
//--------------------------------------------------------------------------
void CAccessorBag::Destroy( CAccessorBase * pAccessor ){ pAccessor->SetInvalid(); Remove(pAccessor);
TRY { while (pAccessor->GetRefcount() > 0) pAccessor->Release(); // this can throw - we'll toss away error
} CATCH( CException, e ) { SCODE sc = GetOleError(e); tbDebugOut(( DEB_ERROR, "CAccessorBase::Release threw 0x%x\n", sc )); } END_CATCH;
if (0 == pAccessor->GetInheritorCount() ) delete pAccessor;} //Destroy
//+-------------------------------------------------------------------------
//
// Member: CAccessorBag::~CAccessorBag, private
//
// Synopsis: Removes accessors the user forgot to free
//
// History: 16 Jan 1997 dlee Created
//
//--------------------------------------------------------------------------
CAccessorBag::~CAccessorBag(){ CAccessorBase *p; while ( p = First() ) { tbDebugOut(( DEB_ITRACE, "App bug: Deleting an accessor that wasn't freed\n" )); Destroy( p ); }} //~CAccessorBag
//+-------------------------------------------------------------------------
//
// Member: CAccessorBag::Release, public
//
// Synopsis: Dereference an accessor; delete it if refcount goes to 0
//
// History: 18 Sep 1996 Alanw Created
//
//--------------------------------------------------------------------------
void CAccessorBag::Release(HACCESSOR hAccessor, ULONG * pcRef){ CAccessorBase *pAccessor = Convert(hAccessor); // will throw if accessor invalid
// caught by ReleaseAccessor
if (0 == pAccessor->Release()) { Destroy(pAccessor); if (pcRef) *pcRef = 0; } else { if (pcRef) *pcRef = pAccessor->GetRefcount(); }} //Release
//+-------------------------------------------------------------------------
//
// Member: CAccessorBag::AddRef, public
//
// Synopsis: Adds a reference to an accessor
//
// History: 18 Sep 1996 Alanw Created
//
//--------------------------------------------------------------------------
void CAccessorBag::AddRef(HACCESSOR hAccessor, ULONG * pcRef){ CAccessorBase *pAccessor = Convert(hAccessor);
ULONG cRef = pAccessor->AddRef(); if (pcRef) *pcRef = cRef;} //AddRef
// This pool has no private data -- it just calls the OLE allocator, so
// it can be static.
CAccessorAllocator CAccessor::_Pool;
//+-------------------------------------------------------------------------
//
// Function: isVariableLength
//
// Synopsis: TRUE if the type is one of the odd oledb types that can
// have variable length inline data
//
// Arguments: [type] -- oledb data type
//
// History: 6 Feb 95 dlee created
//
//--------------------------------------------------------------------------
static BOOL isVariableLength( DWORD type ){ type &= VT_TYPEMASK;
return type == DBTYPE_STR || type == DBTYPE_BYTES || type == DBTYPE_WSTR;} //isVariableLength
//+-------------------------------------------------------------------------
//
// Function: isValidByRef
//
// Synopsis: TRUE if the type is one of the odd oledb types that can
// be combined with DBTYPE_BYREF
//
// Arguments: [type] -- oledb data type
//
// History: 9 Aug 95 dlee created
//
//--------------------------------------------------------------------------
static BOOL isValidByRef( DWORD type ){ type &= ~DBTYPE_BYREF;
return type == DBTYPE_STR || type == DBTYPE_WSTR || type == DBTYPE_BYTES || type == DBTYPE_GUID || type == VT_CF || type == DBTYPE_VARIANT;} //isValidByref
//+-------------------------------------------------------------------------
//
// Function: isEquivalentType
//
// Synopsis: TRUE if the types are interchangable between OLE-DB and
// PROPVARIANT. Unfortunately, several of the types are
// equivalent but have different representations.
//
// Arguments: [vtDst] -- OLE-DB destination type
// [vtSrc] -- PROPVARIANT source type
//
// History: 9 Aug 95 dlee created
//
//--------------------------------------------------------------------------
static BOOL isEquivalentType( VARTYPE vtDst, VARTYPE vtSrc ){ return ( ( vtDst == vtSrc ) || ( ( ( DBTYPE_WSTR | DBTYPE_BYREF ) == vtDst ) && ( VT_LPWSTR == vtSrc ) ) || ( ( ( DBTYPE_STR | DBTYPE_BYREF ) == vtDst ) && ( VT_LPSTR == vtSrc ) ) || ( ( ( DBTYPE_WSTR | DBTYPE_BYREF | DBTYPE_VECTOR ) == vtDst ) && ( ( VT_LPWSTR | VT_VECTOR ) == vtSrc ) ) || ( ( ( DBTYPE_STR | DBTYPE_BYREF | DBTYPE_VECTOR ) == vtDst ) && ( ( VT_LPSTR | VT_VECTOR ) == vtSrc ) ) || ( ( ( DBTYPE_GUID | DBTYPE_BYREF ) == vtDst ) && ( VT_CLSID == vtSrc ) ) || ( ( ( VT_CF | DBTYPE_BYREF ) == vtDst ) && ( VT_CF == vtSrc ) ) );} //isEquivalentType
//+-------------------------------------------------------------------------
//
// Function: NullOrCantConvert, inline
//
// Synopsis: Returns DBSTATUS_S_ISNULL if [type] is one of the types which
// represent null data, DBSTATUS_E_CANTCONVERTVALUE otherwise.
//
// Arguments: [type] -- variant data type
//
// History: 24 Feb 98 AlanW created
//
//--------------------------------------------------------------------------
inline DBSTATUS NullOrCantConvert( VARTYPE type ){ if ( type == VT_EMPTY || type == VT_NULL ) return DBSTATUS_S_ISNULL; else return DBSTATUS_E_CANTCONVERTVALUE;} //NullOrCantConvert
//+---------------------------------------------------------------------------
//
// Function: ConvertBackslashToSlash, inline
//
// Synopsis: Converts '\' characters to '/' in a string inplace.
//
// Arguments: [pwszPath] -- string to be converted
//
// History: 24 Feb 98 AlanW Added header
//
//----------------------------------------------------------------------------
inline void ConvertBackslashToSlash( LPWSTR pwszPath ){ Win4Assert( 0 != pwszPath );
while ( 0 != *pwszPath ) { if ( L'\\' == *pwszPath ) { *pwszPath = L'/'; } pwszPath++; }} //ConvertBackslashToSlash
// DBGP - a debug parameter, only available on checked builds
#ifndef DBGP
#if DBG == 1
#define DBGP(a) , a
#else
#define DBGP(a)
#endif // DBG
#endif // ndef DBGP
//+-------------------------------------------------------------------------
//
// Member: CAccessor::_BindingFailed, private
//
// Synopsis: Stores a binding status for an individual binding error.
// The caller should continue processing with the next binding.
//
// Arguments: [BindStat] -- what when wrong?
// [iBinding] -- which binding was bad?
// [pBindStatus] -- where to indicate bad binding
//
// History: 6 Feb 95 dlee created
//
//--------------------------------------------------------------------------
void CAccessor::_BindingFailed( DBBINDSTATUS BindStat, DBORDINAL iBinding, DBBINDSTATUS* pBindStatus DBGP(char* pszExplanation)){ tbDebugOut(( DEB_TRACE, "CAccessor: construction failed, bindstatus=%x, binding %d\n", BindStat, iBinding ));#if DBG == 1
if (pszExplanation) { tbDebugOut(( DEB_TRACE|DEB_NOCOMPNAME, "\t%s\n", pszExplanation )); }#endif // DBG
if (pBindStatus != 0) { pBindStatus[iBinding] = BindStat; } _scStatus = DB_E_ERRORSOCCURRED;} //_BindingFailed
//+-------------------------------------------------------------------------
//
// Member: CAccessor::_ConstructorFailed, private
//
// Synopsis: Indicate an error with parameters other than an individual
// binding. Throw an exception for the error.
//
// Arguments: [scFailure] -- what when wrong?
//
// History: 16 Sep 1996 AlanW created
//
//--------------------------------------------------------------------------
void CAccessor::_ConstructorFailed( SCODE scFailure DBGP(char* pszExplanation)){ tbDebugOut(( DEB_TRACE, "CAccessor: construction failed, sc=%x\n", scFailure ));#if DBG == 1
if (pszExplanation) { tbDebugOut(( DEB_TRACE|DEB_NOCOMPNAME, "\t%s\n", pszExplanation )); }#endif // DBG
_scStatus = scFailure;
QUIETTHROW(CException(scFailure));} //_ConstructorFailed
static const GUID s_guidStorage = PSGUID_STORAGE;static const GUID s_guidQuery = DBQUERYGUID;const DBORDINAL colInvalid = -1;
//+---------------------------------------------------------------------------
//
// Member: CAccessor::_Initialize
//
// Synopsis: Initializes the object without verifying the coercions.
//
// Arguments: [dwAccessorFlags] - accessor flags, read/write, etc.
// [cBindings] - count of bindings
// [rgBindings] - array of binding structures
// [pBindStat] - on return, pointer to first binding in error
//
// History: 21 Nov 94 dlee created
// 11-07-95 srikants Moved from constructor
//
// Notes:
//
//----------------------------------------------------------------------------
void CAccessor::_Initialize( DBACCESSORFLAGS dwAccessorFlags, DBORDINAL cBindings, const DBBINDING * rgBindings, DBBINDSTATUS * pBindStat){ // Invalid accessor flag?
if ( dwAccessorFlags & ~ ( DBACCESSOR_PASSBYREF | DBACCESSOR_ROWDATA | DBACCESSOR_PARAMETERDATA | DBACCESSOR_OPTIMIZED) ) _ConstructorFailed(DB_E_BADACCESSORFLAGS DBGP("bad dwAccessorFlags bits"));
if ( (dwAccessorFlags & ( DBACCESSOR_ROWDATA | DBACCESSOR_PARAMETERDATA ) ) == 0) _ConstructorFailed(DB_E_BADACCESSORFLAGS DBGP("bad dwAccessorFlags type"));
if ( dwAccessorFlags & DBACCESSOR_PARAMETERDATA ) _ConstructorFailed(DB_E_BADACCESSORFLAGS DBGP("parameter accessors are not supported"));
// byref accessors are not supported
if ( dwAccessorFlags & ( DBACCESSOR_PASSBYREF) ) _ConstructorFailed(DB_E_BYREFACCESSORNOTSUPPORTED DBGP("byref accessors are not supported"));
// null accessors are not supported
if ( 0 == _cBindings ) _ConstructorFailed(DB_E_NULLACCESSORNOTSUPPORTED DBGP("null accessors are not supported"));
// verify each binding is ok and save it
for (DBORDINAL iBinding = 0; iBinding < _cBindings; iBinding++) { CDataBinding DataBinding (rgBindings[iBinding]); DBPART cp = DataBinding.Binding().dwPart; DBTYPE wType = DataBinding.Binding().wType;
if (0 != pBindStat) pBindStat[iBinding] = DBBINDSTATUS_OK;
// check for invalid bits in the column parts
if (cp & ~(DBPART_VALUE | DBPART_LENGTH | DBPART_STATUS)) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad dwPart bits"));
// at least one of value, length or status flags must be on
if (0 == (cp & (DBPART_VALUE | DBPART_LENGTH | DBPART_STATUS))) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("zero dwPart"));
// we don't support abstract data types
if (0 != DataBinding.Binding().pTypeInfo) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad pTypeInfo"));
if (0 != DataBinding.Binding().pBindExt) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad pBindExt"));
if (0 != (DataBinding.Binding().dwFlags & DBBINDFLAG_HTML)) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("no HTML binding support")); else if (0 != DataBinding.Binding().dwFlags) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad dwFlags"));
//
// Verify size and alignment of output buffer. Set cbWidth in local
// copy of binding to handle length of fixed-width types correctly.
//
if ( 0 != ( wType & DBTYPE_BYREF ) ) { if ( ! isValidByRef( wType ) ) _BindingFailed( DBBINDSTATUS_BADBINDINFO, iBinding, pBindStat DBGP("byref on non-byref type") );
// byref data: client's cbMaxLen is noise
DataBinding.SetMaxLen(sizeof LPWSTR); } else if ( 0 != ( wType & DBTYPE_VECTOR ) ) { USHORT cbWidth = sizeof ( DBVECTOR ); USHORT cbAlign = sizeof ( DBVECTOR );
#if CIDBG==1
tbDebugOut(( DEB_ACCESSOR, "type %d, obValue %d, alignment needed: %d\n", (int) wType, (int) DataBinding.Binding().obValue, (int) cbAlign ));
//Win4Assert( (0 == (DBPART_VALUE & cp)) ||
// ( (0 != cbAlign) &&
// (0 == (DataBinding.Binding().obValue % cbAlign)) ) );
if ( (DBPART_VALUE & cp) && (0 != (DataBinding.Binding().obValue % cbAlign)) ) { tbDebugOut(( DEB_ERROR, "bad value alignment for DBVECTOR, obValue %d, alignment needed: %d\n", (int) DataBinding.Binding().obValue, (int) cbAlign )); } #endif // CIDBG==1
// Fixed-length data types needn't have their width set, per
// the Nile spec. So we set it to the default for the type.
DataBinding.SetMaxLen( cbWidth ); } else if ( 0 != ( wType & VT_ARRAY ) ) { DataBinding.SetMaxLen( sizeof( SAFEARRAY * ) ); } else { USHORT cbWidth,cbAlign,gfFlags;
CTableVariant::VartypeInfo( wType, cbWidth, cbAlign, gfFlags );
#if CIDBG==1
tbDebugOut(( DEB_ACCESSOR, "type %d, obValue %d, alignment needed: %d\n", (int) wType, (int) DataBinding.Binding().obValue, (int) cbAlign ));
//Win4Assert( (0 == (DBPART_VALUE & cp)) ||
// ( (0 != cbAlign) &&
// (0 == (DataBinding.Binding().obValue % cbAlign)) ) );
if ( (DBPART_VALUE & cp) && (0 != (DataBinding.Binding().obValue % cbAlign)) ) { tbDebugOut(( DEB_ERROR, "bad value alignment for type %d, obValue %d, alignment needed: %d\n", (int) wType, (int) DataBinding.Binding().obValue, (int) cbAlign )); } #endif // CIDBG==1
// Fixed-length data types needn't have their width set, per
// the Nile spec. So we set it to the default for the type.
if (! isVariableLength( wType ) ) DataBinding.SetMaxLen( cbWidth ); }
if (DataBinding.Binding().dwMemOwner & ~(DBMEMOWNER_PROVIDEROWNED)) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad dwMemOwner bits"));
if (DBTYPE_EMPTY == (wType & VT_TYPEMASK) || DBTYPE_NULL == (wType & VT_TYPEMASK) || 0 != (wType & VT_RESERVED)) { _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad wType")); }
if ((wType & ~VT_TYPEMASK) != 0 && (wType & ~VT_TYPEMASK) != DBTYPE_ARRAY && (wType & ~VT_TYPEMASK) != DBTYPE_VECTOR && (wType & ~VT_TYPEMASK) != DBTYPE_BYREF ) { _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad wType modifier combination")); }
// SPECDEVIATION - this is bogus; DBTYPE_VARIANT must be supported!
if ((DataBinding.Binding().dwMemOwner & DBMEMOWNER_PROVIDEROWNED) && (wType != DBTYPE_BSTR) && !(wType & (DBTYPE_BYREF | DBTYPE_VECTOR | DBTYPE_ARRAY ))) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("bad provider-owned mem type"));
if ( (DataBinding.Binding().dwMemOwner & DBMEMOWNER_PROVIDEROWNED) && (wType == (DBTYPE_BYREF|DBTYPE_VARIANT)) && ! _fExtendedTypes ) _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStat DBGP("provider-owned mem without extended types"));
_aBindings[ iBinding] = DataBinding;
if ( DataBinding.Binding().pObject ) { _aBindings[iBinding].Binding().pObject = new DBOBJECT;
RtlCopyMemory( _aBindings[(unsigned)iBinding].Binding().pObject, DataBinding.Binding().pObject, sizeof( DBOBJECT ) ); } }
// Verify that none of the output offsets and lengths overlap with
// any others. This must be run after the above loop so cbMaxLength
// fields are properly initialized.
if (_scStatus == S_OK) _ValidateOffsets( pBindStat );} //_Initialize
//+---------------------------------------------------------------------------
//
// Member: CAccessor::Validate
//
// Synopsis: Validates the coercions with respect to the ColumnsInfo.
//
// Arguments: [rColumnsInfo] - The column info. for the rowset
// [pBindStat] - Binding status array (optional)
//
// History: 21 Nov 94 dlee created
// 11-08-95 srikants Created
// 01-15-98 VikasMan Removed call to checkcoercion here
// Checking done only in GetData now
//
//----------------------------------------------------------------------------
void CAccessor::Validate( CColumnsInfo & rColumnsInfo, DBBINDSTATUS * pBindStatus ){ _pColumnsInfo = &rColumnsInfo; Win4Assert( 0 != _pColumnsInfo );
for (DBORDINAL iBinding = 0; iBinding < _cBindings; iBinding++) { CDataBinding & DataBinding = _aBindings[iBinding]; DBTYPE wType = (DBTYPE) DataBinding.Binding().wType;
//
// Make sure the column id is valid. Remember, column numbers are
// 1-based. Map columnid 0 to the row ID column for the bookmark.
//
DBORDINAL iColumnId = DataBinding.Binding().iOrdinal;
if ( ! _pColumnsInfo->IsValidColumnId( (ULONG) iColumnId ) ) { _BindingFailed(DBBINDSTATUS_BADORDINAL, iBinding, pBindStatus DBGP("invalid iOrdinal")); continue; }
const DBCOLUMNINFO & rColInfo = _pColumnsInfo->Get1ColumnInfo( (ULONG) iColumnId );
if ( DBTYPE_HCHAPTER == wType && !(rColInfo.dwFlags & DBCOLUMNFLAGS_ISCHAPTER) ) { _BindingFailed(DBBINDSTATUS_UNSUPPORTEDCONVERSION, iBinding, pBindStatus DBGP("Chapter type binding to non-chapter column")); continue; }
//
// The only IUNKNOWN binding we currently support is for the
// DBCOL_SELFCOLUMNS guid, with propid PROPID_DBSELF_SELF.
// We don't yet support binding to a particular column, just
// to the row (file) as a whole, and only if the client is FSCI.
//
if ( DBTYPE_IUNKNOWN == wType ) { // Map self to the rowid column
if ( ( DBCOL_SELFCOLUMNS == rColInfo.columnid.uGuid.guid ) && ( PROPID_DBSELF_SELF == rColInfo.columnid.uName.ulPropid ) ) DataBinding.SetDataColumn( _pColumnsInfo->GetRowIdColumn() ); else _BindingFailed(DBBINDSTATUS_BADBINDINFO,iBinding,pBindStatus DBGP("bad IUNKNOWN binding")); }
// If it's the path column, save the column # for possible use later
// when doing deferred or self loads
if ( rColInfo.columnid.uGuid.guid == s_guidStorage && rColInfo.columnid.uName.ulPropid == PID_STG_PATH ) _iPathColumn = DataBinding.GetDataColumn();
// If it's the vpath column, save the column # for later use. We
// need to translate '\' to '/' in the vpath column.
if ( rColInfo.columnid.uGuid.guid == s_guidQuery && rColInfo.columnid.uName.ulPropid == DISPID_QUERY_VIRTUALPATH ) _iVpathBinding = iBinding;
// If it's a bookmark column, map it to the corresponding row ID
// column for retrieval.
if ( (rColInfo.dwFlags & DBCOLUMNFLAGS_ISBOOKMARK) && ! ( rColInfo.dwFlags & DBCOLUMNFLAGS_ISCHAPTER ) ) DataBinding.SetDataColumn( _pColumnsInfo->GetRowIdColumn() );
// If it's a chapter column, mark it to Addref the chapter on retrieval
if ( (rColInfo.dwFlags & DBCOLUMNFLAGS_ISCHAPTER) && (DBPART_VALUE & DataBinding.Binding().dwPart) ) DataBinding.SetChapter( TRUE ); }
// look for pathname -- it may be in the rowbuffer columns, but not
// in the accessor's bindings.
if ( colInvalid == _iPathColumn ) { for ( ULONG x = 0; x < rColumnsInfo.GetHiddenColumnCount(); x++ ) { CFullPropSpec const &spec = *rColumnsInfo.GetPropSpec( x+1 );
tbDebugOut(( DEB_ACCESSOR, "spec 0x%x IsPropid %d, propid 0x%x, pathpropid: 0x%x\n", &spec, spec.IsPropertyPropid(), spec.GetPropertyPropid(), PID_STG_PATH ));
if ( spec.IsPropertyPropid() && PID_STG_PATH == spec.GetPropertyPropid() && s_guidStorage == spec.GetPropSet() ) { _iPathColumn = x+1; break; } } }
_idColInfo = _pColumnsInfo->GetId();} //Validate
//+-------------------------------------------------------------------------
//
// Member: CAccessor::CAccessor, public
//
// Synopsis: Constructs an accessor object
//
// Arguments: [dwAccessorFlags] -- accessor flags
// [cBindings] -- # of bindings specified
// [rgBindings] -- array of bindings
// [pBindStat] -- returns index of bad binding (if any)
// [fExtTypes] -- TRUE if extended variants are supported
// [pColumns] -- column info for early checking of column
// coercions
// [type] -- type of accessor
// [pCreator] --
//
// History: 21 Nov 94 dlee created
//
//--------------------------------------------------------------------------
CAccessor::CAccessor( DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings, const DBBINDING * rgBindings, DBBINDSTATUS * pBindStat, BOOL fExtTypes, CColumnsInfo * pColumns, EAccessorType type, void * pCreator) : CAccessorBase(pCreator, type), _dwAccessorFlags(dwAccessorFlags), _scStatus(S_OK), _aBindings( (unsigned) cBindings), _cBindings(cBindings), _idColInfo(0), _pColumnsInfo(0), _iPathColumn( colInvalid ), _iVpathBinding( colInvalid ), _fExtendedTypes( fExtTypes ){ _Initialize( dwAccessorFlags, cBindings, rgBindings, pBindStat );
if ( 0 != pColumns && _scStatus == S_OK ) Validate( *pColumns, pBindStat ); if (_scStatus != S_OK) QUIETTHROW(CException(_scStatus));} //CAccessor
//+-------------------------------------------------------------------------
//
// Member: CAccessor::~CAccessor, public
//
// Synopsis: Destructs an accessor object
//
// History: 19 Apr 2000 dlee added header
//
//--------------------------------------------------------------------------
CAccessor::~CAccessor(){ // Delete DBOBJECTs
for ( unsigned iBinding = 0; iBinding < _cBindings; iBinding++ ) { if ( 0 != _aBindings[iBinding].Binding().pObject ) delete _aBindings[iBinding].Binding().pObject;
// These are for future use according to OLE-DB 2.0 and should be NULL
Win4Assert( 0 == _aBindings[iBinding].Binding().pTypeInfo && 0 == _aBindings[iBinding].Binding().pBindExt ); }
CAccessorBase * pParent = GetParent();
if ( 0 != pParent ) { if ( 0 == pParent->DecInheritors() && 0 == pParent->GetRefcount() ) delete pParent; }} //~CAccessor
//+-------------------------------------------------------------------------
//
// Member: CAccessor::_ValidateOffsets, private
//
// Synopsis: Checks a binding for overlapping output fields
//
// Arguments: [pBindStat] -- where to indicate bad binding
//
// History: 18 May 1995 dlee Created
//
//--------------------------------------------------------------------------
void CAccessor::_ValidateOffsets( DBBINDSTATUS * pBindStatus ){ for ( DBORDINAL iBinding = 0; iBinding < _cBindings; iBinding++ ) { CDataBinding & DataBinding = _aBindings[ iBinding];
COffsetLengthPair aPairs[3]; ULONG cPairs = 0; DataBinding.CollectOutputPairs( aPairs, cPairs );
// Check for overlap with data/length/status in this binding
for ( DBORDINAL i = 0; i < cPairs; i++ ) { for ( DBORDINAL j = i + 1; j < cPairs; j++) { if ( aPairs[i].isInConflict( aPairs[j] ) ) { _BindingFailed( DBBINDSTATUS_BADBINDINFO, iBinding, pBindStatus DBGP("intra-binding field overlap") ); continue; } } }
// Check for overlap with other bindings
for ( i = iBinding + 1; i < _cBindings; i++ ) { CDataBinding &binding = _aBindings[i]; COffsetLengthPair aTestPairs[3]; ULONG cTestPairs = 0; binding.CollectOutputPairs( aTestPairs, cTestPairs );
for (ULONG iPair = 0; iPair < cPairs; iPair++) { for (ULONG iTestPair = 0; iTestPair < cTestPairs; iTestPair++) { if ( aPairs[iPair].isInConflict( aTestPairs[iTestPair] ) ) { _BindingFailed( DBBINDSTATUS_BADBINDINFO, i, pBindStatus DBGP("inter-binding field overlap") ); continue; } } } } }} //_ValidateOffsets
//+---------------------------------------------------------------------------
//
// Member: CAccessor::CanConvertType, static public
//
// Synopsis: Indicate whether a type conversion is valid.
//
// Arguments: [wFromType] -- source type
// [wToType] -- destination type
// [fExTypes] -- TRUE if extended types allowed
// [xDataConvert] -- OLEDB IDataConvert interface pointer
//
// Returns: TRUE if the conversion is available, FALSE otherwise.
// Throws E_FAIL or E_INVALIDARG on errors.
//
// History: 20 Nov 96 AlanW Created
// 14 Jan 98 VikasMan Add xDataConvert parameter
//
//----------------------------------------------------------------------------
BOOL CAccessor::CanConvertType( DBTYPE wFromType, DBTYPE wToType, BOOL fExTypes, XInterface<IDataConvert>& xDataConvert){ USHORT cbData, cbAlignFrom, rgfFlagsFrom; CTableVariant::VartypeInfo(wFromType, cbData, cbAlignFrom, rgfFlagsFrom);
USHORT cbAlignTo, rgfFlagsTo; CTableVariant::VartypeInfo(wToType, cbData, cbAlignTo, rgfFlagsTo);
if (0 == cbAlignFrom || 0 == cbAlignTo) QUIETTHROW(CException(E_INVALIDARG)); // bad type
if ( ((wToType & ~VT_TYPEMASK) != 0 && (wToType & ~VT_TYPEMASK) != DBTYPE_ARRAY && (wToType & ~VT_TYPEMASK) != DBTYPE_VECTOR && (wToType & ~VT_TYPEMASK) != DBTYPE_BYREF ) || 0 != (wToType & VT_RESERVED) ) { tbDebugOut(( DEB_IERROR, "CanConvertType: conversion to invalid type")); QUIETTHROW(CException(E_INVALIDARG)); }
if ( ((wFromType & ~VT_TYPEMASK) != 0 && (wFromType & ~VT_TYPEMASK) != DBTYPE_ARRAY && (wFromType & ~VT_TYPEMASK) != DBTYPE_VECTOR && (wFromType & ~VT_TYPEMASK) != DBTYPE_BYREF ) || 0 != (wFromType & VT_RESERVED) ) { tbDebugOut(( DEB_IERROR, "CanConvertType: conversion from invalid type")); QUIETTHROW(CException(E_INVALIDARG)); }
//
// check for conversions _Initialize() does not allow
//
// check if byref request for "short" type
if ( (wToType & DBTYPE_BYREF) && !isValidByRef(wToType) ) { tbDebugOut(( DEB_IERROR, "CanConvertType: conversion to byref type for short type")); return FALSE; }
if ( DBTYPE_EMPTY == (wToType & VT_TYPEMASK) || DBTYPE_NULL == (wToType & VT_TYPEMASK) )
{ tbDebugOut(( DEB_IERROR, "CanConvertType: conversion to empty or null type")); return FALSE; }
//
// check extended type conversions
//
// NEWFEATURE: - vector ==> array conversion?
if ((wToType & DBTYPE_ARRAY) && (wToType != wFromType)) { tbDebugOut(( DEB_IERROR, "CanConvertType: conversion to array")); return FALSE; } if ((wToType & DBTYPE_VECTOR) && !(isEquivalentType(wToType,wFromType) || wFromType == VT_VARIANT)) { tbDebugOut(( DEB_IERROR, "CanConvertType: conversion to vector")); return FALSE; }
//
// VARIANT conversions depend upon whether extended types are supported
//
if (wToType == DBTYPE_VARIANT) { if (fExTypes) return TRUE;
if ( (wFromType & ~(DBTYPE_BYREF)) == DBTYPE_GUID) return FALSE;
return TRUE; }
//
// Anything can coerce into DBTYPE_BYTES
//
if (wToType == DBTYPE_BYTES) return TRUE;
// now use OLEDB to check if conversion is possible
return COLEDBVariant::CanConvertType( wFromType, wToType, xDataConvert );
} //CanConvertType
//+-------------------------------------------------------------------------
//
// Member: CAccessor::GetBindings, public
//
// Synopsis: Fetches a copy of the bindings used by the accessor
//
// Arguments: [pAccessorFlags] -- accessor flags
// [pcBindings] -- # of bindings returned
// [ppBindings] -- array of bindings returned. the user
// must IMalloc::Free this memory.
//
// Returns: SCODE - S_OK. Return value required by base class
// CAccessorBase
//
// History: 21 Nov 94 dlee created
// 05 May 97 emilyb switched first 2 params from
// references to pointers so that
// this can be a virtual member of
// CAccessorBase. (CDistributedAccessor
// cannot use references).
//
//--------------------------------------------------------------------------
SCODE CAccessor::GetBindings( DBACCESSORFLAGS * pAccessorFlags, DBCOUNTITEM * pcBindings, DBBINDING ** ppBindings){ // in case of an error later, init the count to a good state
*pcBindings = 0;
// verify this pointer is good
*ppBindings = 0;
// allocate room for the bindings and copy them
*ppBindings = (DBBINDING *) _Pool.Allocate( (ULONG) _cBindings * sizeof DBBINDING );
*pAccessorFlags = _dwAccessorFlags; *pcBindings = _cBindings;
for ( DBORDINAL i = 0; i < _cBindings; i++ ) { (*ppBindings)[i] = _aBindings[ i].Binding();
if ( _aBindings[i].Binding().pObject ) { (*ppBindings)[i].pObject = (DBOBJECT*) _Pool.Allocate( sizeof( DBOBJECT ) );
RtlCopyMemory( (*ppBindings)[i].pObject, _aBindings[i].Binding().pObject, sizeof( DBOBJECT ) ); }
// These are for future use according to OLE-DB 2.0 and should be NULL
Win4Assert( 0 == _aBindings[i].Binding().pTypeInfo && 0 == _aBindings[i].Binding().pBindExt ); }
return S_OK;} //GetBindings
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessor::_LoadPath, private
//
// Synopsis: Loads the path of the object represented by the row
//
// Arguments: [rSrcSet] -- set of source columns
// [pbSrc] -- source row buffer
// [funnyPath] -- where to put the path
//
// History: 30 May 95 dlee created
//
//--------------------------------------------------------------------------
void CRowDataAccessor::_LoadPath( CTableColumnSet & rSrcSet, BYTE * pbSrc, CFunnyPath & funnyPath ){ // either path or workid must be available -- it's added by ColInfo
// when the query is created.
if ( colInvalid != _iPathColumn ) { // pathname happened to be one of the columns -- this is faster than
// doing a wid translation
CTableColumn *pPathCol = rSrcSet.Find( (ULONG) _iPathColumn );
WCHAR *pwc = 0; if (pPathCol->GetStoredType() == VT_LPWSTR) { pwc = * ( (WCHAR **) (pbSrc + pPathCol->GetValueOffset()) ); } else { Win4Assert(pPathCol->GetStoredType() == VT_VARIANT); CTableVariant & varnt = * ( (CTableVariant *) (pbSrc + pPathCol->GetValueOffset()) ); if (varnt.vt == VT_LPWSTR) pwc = varnt.pwszVal; }
if (pwc) { funnyPath.SetPath( pwc ); } } else { // translate the wid for the row into a pathname
Win4Assert( colInvalid != _pColumnsInfo->GetRowIdColumn() ); _pQuery->WorkIdToPath( _RowWid( rSrcSet, pbSrc ), funnyPath ); }} //_LoadPath
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessor::_BindToObject, private
//
// Synopsis: Binds to an object and returns an interface pointer
//
// Arguments: [pbDst] -- destination row buffer
// [rDstBinding] -- binding for the destination
// [pbSrc] -- source row buffer
// [rSrcColumn] -- source column description
// [rSrcSet] -- set of source columns
//
// Returns: DBSTATUS -- status of the column copy
//
// History: 10 Apr 95 dlee created
//
//--------------------------------------------------------------------------
DBSTATUS CRowDataAccessor::_BindToObject( BYTE * pbDst, CDataBinding & rDstBinding, BYTE * pbSrc, CTableColumn & rSrcColumn, CTableColumnSet & rSrcSet){ //
// CLEANCODE: This is all wrong. StgOpenStorage doesn't belong in
// framework code! Though fixing this would be hard -- we'd have to
// remote the object binding from the server process. And we only
// try this for the path column -- if it doesn't exist this code won't
// be executed.
//
DBSTATUS DstStatus = 0;
// get the pathname for ole to open the storage
CFunnyPath funnyPath; _LoadPath( rSrcSet, pbSrc, funnyPath );
// bind to the file and return interface pointer requested
if ( 0 != funnyPath.GetActualLength() ) { // WORKAROUND: StgOpenStorage AVs for paths > MAX_PATH currently
// So till it is fixed, make sure we do not pass a path > MAX_PATH
if ( funnyPath.GetLength() < MAX_PATH ) { XInterface<IStorage> xStorage; SCODE sc = StgOpenStorage( funnyPath.GetPath(), 0, rDstBinding.Binding().pObject->dwFlags, 0, 0, xStorage.GetPPointer() ); if ( SUCCEEDED( sc ) ) sc = xStorage->QueryInterface( rDstBinding.Binding().pObject->iid, (void **) pbDst ); if ( FAILED( sc ) ) DstStatus = DBSTATUS_E_CANTCREATE; } else { ciDebugOut(( DEB_WARN, "Not calling StgOpenStorage in CRowDataAccessor::_BindToObject for paths > MAX_PATH: \n(%ws)\n", funnyPath.GetPath() )); DstStatus = DBSTATUS_E_CANTCREATE; } } else DstStatus = DBSTATUS_S_ISNULL;
return DstStatus;} //_BindToObject
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessor::_LoadDeferred, private
//
// Synopsis: Loads a non-storage property value. Only called if the
// value is large, hence not already loaded.
//
// Arguments: [rSrcVar] -- where the value is written
// [pbSrc] -- pointer to the row data (to get the wid)
// [iColumn] -- column being copied
// [rSrcSet] -- set of source columns
//
// Returns: DBSTATUS -- status of the load
//
// History: 1 Jun 95 dlee created
//
//--------------------------------------------------------------------------
DBSTATUS CRowDataAccessor::_LoadDeferred( CTableVariant & rSrcVar, BYTE * pbSrc, DBORDINAL iColumn, CTableColumnSet & rSrcSet){ // If the property set storage has not yet been opened for this object,
// load it now.
tbDebugOut(( DEB_ACCESSOR, "loading deferred value\n" ));
rSrcVar.vt = VT_EMPTY; // just in case we can't load anything
CFullPropSpec const *ps = _pColumnsInfo->GetPropSpec( (ULONG) _aBindings[iColumn].GetDataColumn() );
//
// Try loading from the property cache/docfile if the workid column is
// available.
//
DBORDINAL rowIdCol = _pColumnsInfo->GetRowIdColumn(); if ( ( colInvalid == rowIdCol ) || ( !_pQuery->FetchDeferredValue( _RowWid( rSrcSet, pbSrc ), *ps, rSrcVar ) ) ) { return DBSTATUS_S_ISNULL; }
tbDebugOut(( DEB_ACCESSOR, "successfully loaded deferred value\n" ));
return DBSTATUS_S_OK;} //_LoadDeferred
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessor::_ComplexCopy, private
//
// Synopsis: Do a complex copy of the value to the client's buffer
//
// Arguments: [rDstBinding] -- binding for the destination
// [pbSrc] -- source row buffer
// [rSrcColumn] -- source column description
// [iColumn] -- column being copied
// [vtSrc] -- type of the source
// [cbDstLength] -- on exit, size of destination data
// [pbSrcData] -- pointer to source data
// [vtDst] -- type of the destination value
// [pbDstData] -- where to write the value
// [rSrcSet] -- set of source columns
// [rRowBuffer] -- row buffer
// [hrow] -- hrow being retrieved
// [xDataConvert] -- smart pointer to IDataConvert interface.
// this is to be passed along and used finally
// in COLEDBVariant::CopyOrCoerce
//
// Returns: DBSTATUS -- status of the column copy
//
// History: 01 Jun 1995 dlee created
// 09 Jan 1998 vikasman added xDataConvert parameter
//
//--------------------------------------------------------------------------
DBSTATUS CRowDataAccessor::_ComplexCopy( CDataBinding & rDstBinding, BYTE * pbSrc, CTableColumn & rSrcColumn, DBORDINAL iColumn, VARTYPE vtSrc, DBLENGTH & cbDstLength, BYTE * pbSrcData, VARTYPE vtDst, BYTE * pbDstData, CTableColumnSet & rSrcSet, CRowBuffer & rRowBuffer, HROW hrow, XInterface<IDataConvert>& xDataConvert){ DBSTATUS DstStatus = DBSTATUS_S_OK;
// Convert to a COLEDBVariant, then copy it using the OLEDBConvert
// method. This allows coercions and variant to nonvariant, etc.
// conversions to occur.
COLEDBVariant SrcVar; BOOL fDoCopy = TRUE; BOOL fFreeDeferredSrc = FALSE;
if ( VT_VARIANT == vtSrc ) { Win4Assert(rSrcColumn.GetValueSize() == sizeof PROPVARIANT);
if ( ( rSrcColumn.IsDeferred( pbSrc ) ) ) { DstStatus = _LoadDeferred( SrcVar, pbSrc, iColumn, rSrcSet );
if ( DBStatusOK ( DstStatus ) ) { // Attempt to store the data without using OLEDBConvert
if ( (VT_VARIANT == vtDst && _fExtendedTypes) || DBTYPE_PROPVARIANT == vtDst ) { fDoCopy = FALSE; * (PROPVARIANT *) pbDstData = SrcVar; cbDstLength = sizeof (PROPVARIANT); } else if ( (VT_VARIANT|DBTYPE_BYREF) == vtDst || (DBTYPE_PROPVARIANT|DBTYPE_BYREF) == vtDst ) { fDoCopy = FALSE;
// Slam the variant into the src data row buffer, then
// hand out a pointer to that variant.
// We need a home for the variant portion, and that
// place should do fine.
// The value portion of the variant will still be
// owned by the row buffer as a normal deferred value.
* (PROPVARIANT *) pbSrcData = SrcVar; * (PROPVARIANT **) pbDstData = (PROPVARIANT *) pbSrcData; cbDstLength = sizeof (PROPVARIANT); } else if ( isEquivalentType( vtDst, SrcVar.vt ) && SrcVar.VariantPointerInFirstWord() ) { // Grab the pointer value out of the variant; any ptr will do
fDoCopy = FALSE; * ( (LPWSTR *) pbDstData ) = SrcVar.pwszVal;
if ( SrcVar.vt & VT_ARRAY ) { cbDstLength = sizeof (SAFEARRAY *); } else { switch (SrcVar.vt ) { case VT_LPWSTR: cbDstLength = wcslen(SrcVar.pwszVal) * sizeof (WCHAR); break; case VT_LPSTR: cbDstLength = strlen(SrcVar.pszVal) * sizeof (char); break; case VT_BSTR: cbDstLength = sizeof (BSTR); break; case VT_CLSID: cbDstLength = sizeof (GUID); break; case VT_CF: cbDstLength = sizeof (CLIPDATA); break; default: tbDebugOut(( DEB_ERROR, "SrcVar.vt = 0x%x\n", SrcVar.vt )); Win4Assert( SrcVar.vt != VT_EMPTY && !"unexpected variant type!" ); } } } else if ( SrcVar.vt == vtDst ) { Win4Assert( vtDst & DBTYPE_VECTOR ); Win4Assert( vtDst != VT_VARIANT ); fDoCopy = FALSE; * (CAL *) pbDstData = SrcVar.cal; cbDstLength = 0; // vectors defined to be 0 len
} else fFreeDeferredSrc = TRUE; } else fDoCopy = FALSE; } else { RtlCopyMemory( &SrcVar, pbSrcData, sizeof SrcVar ); } } else SrcVar.Init( vtSrc, pbSrcData, rSrcColumn.GetValueSize() );
if ( fDoCopy ) { DstStatus = SrcVar.OLEDBConvert( pbDstData, rDstBinding.GetMaxLen(), vtDst, _Pool, cbDstLength, xDataConvert, _fExtendedTypes, ((DBBINDING&)rDstBinding).bPrecision, ((DBBINDING&)rDstBinding).bScale );
// Free the deferred value that was in a format that couldn't be
// used directly (and had to be converted).
if ( fFreeDeferredSrc ) { PropVariantClear( &SrcVar ); } }
// If accessor is byref and we had to allocate memory to return a
// deferred value, we have to tell the row buffer to let go of
// the memory when the HROW is released.
if ( ( DBSTATUS_S_OK == DstStatus ) && ( rSrcColumn.IsDeferred( pbSrc ) ) && ( rDstBinding.Binding().dwMemOwner == DBMEMOWNER_PROVIDEROWNED ) && ( ( vtDst & (DBTYPE_BYREF | DBTYPE_ARRAY | DBTYPE_VECTOR) ) || ( vtDst == VT_LPWSTR ) || ( vtDst == VT_LPSTR ) || ( vtDst == DBTYPE_BSTR ) ) ) { PROPVARIANT var; var.vt = vtDst;
if ( ( DBTYPE_VARIANT | DBTYPE_BYREF ) == vtDst || ( DBTYPE_PROPVARIANT | DBTYPE_BYREF ) == vtDst ) var = ** (PROPVARIANT **) pbDstData; else if ( vtDst & DBTYPE_VECTOR ) RtlCopyMemory( &var.calpwstr, pbDstData, sizeof DBVECTOR ); else var.pwszVal = * (WCHAR **) pbDstData;
tbDebugOut(( DEB_ITRACE, "save away type %x, val %x\n", (int) vtDst, ( vtDst & DBTYPE_VECTOR ) ? (WCHAR *) var.calpwstr.pElems : var.pwszVal ) );
CDeferredValue value( hrow, var ); rRowBuffer.AddDeferredValue( value ); rRowBuffer.SetByrefData( pbSrc ); }
return DstStatus;} //_ComplexCopy
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessor::_ByRefCopy, private
//
// Synopsis: Copy a ByRef value. This hands out a live pointer into the
// row buffer's storage that the client can read from but not
// write to or try to free.
//
// Arguments: [rDstBinding] -- binding for the destination
// [pbSrc] -- source row buffer
// [rSrcColumn] -- source column description
// [vtSrc] -- type of the source
// [rSrcVar] -- variant to fill as a copy of the source
// data in variant form if the source data
// is not already a variant (and thus has
// a length column in the row buffer)
// [pbSrcData] -- pointer to source data
// [vtDst] -- type of the destination value
// [pbDstData] -- where to write the value
//
// Returns: DBSTATUS -- status of the column copy
//
// Notes: Coercions are not supported. This makes sense -- if you
// want slow coercions you shouldn't be binding byref in the
// first place.
//
// History: 25 Jul 95 dlee created
//
//--------------------------------------------------------------------------
DBSTATUS CRowDataAccessor::_ByRefCopy( CDataBinding & rDstBinding, BYTE * pbSrc, CTableColumn & rSrcColumn, VARTYPE vtSrc, CTableVariant & rSrcVar, BYTE * pbSrcData, VARTYPE vtDst, BYTE * pbDstData ){ DBSTATUS DstStatus = DBSTATUS_S_OK; RtlZeroMemory( &rSrcVar, sizeof CTableVariant );
if ( VT_EMPTY == vtSrc ) return DBSTATUS_S_ISNULL;
if ( rDstBinding.Binding().wType & DBTYPE_VECTOR ) { if ( DBTYPE_VARIANT == vtSrc ) { CTableVariant & varnt = * ( (CTableVariant *) pbSrcData );
tbDebugOut(( DEB_ACCESSOR, "byref copy, vtDst 0x%x varnt.vt 0x%x\n", vtDst, varnt.vt ));
if ( isEquivalentType( vtDst, varnt.vt ) ) RtlCopyMemory( pbDstData, &(varnt.caub), sizeof DBVECTOR ); else DstStatus = NullOrCantConvert( varnt.vt ); } else if ( isEquivalentType( vtDst, vtSrc ) ) { RtlCopyMemory( pbDstData, pbSrcData, sizeof DBVECTOR );
// Make a variant in case length is bound for this column
rSrcVar.vt = vtSrc; RtlCopyMemory( &(rSrcVar.caub), pbSrcData, sizeof DBVECTOR ); } else { DstStatus = DBSTATUS_E_CANTCONVERTVALUE; } } else if ( rDstBinding.Binding().wType & DBTYPE_ARRAY ) { if ( DBTYPE_VARIANT == vtSrc ) { CTableVariant & varnt = * ( (CTableVariant *) pbSrcData );
tbDebugOut(( DEB_ACCESSOR, "byref copy, vtDst 0x%x varnt.vt 0x%x\n", vtDst, varnt.vt ));
if ( isEquivalentType( vtDst, varnt.vt ) ) RtlCopyMemory( pbDstData, &(varnt.parray), sizeof (SAFEARRAY *) ); else DstStatus = NullOrCantConvert( varnt.vt ); } else if ( isEquivalentType( vtDst, vtSrc ) ) { RtlCopyMemory( pbDstData, pbSrcData, sizeof (SAFEARRAY *) );
// Make a variant in case length is bound for this column
rSrcVar.vt = vtSrc; RtlCopyMemory( &(rSrcVar.parray), pbSrcData, sizeof (SAFEARRAY *) ); } else { DstStatus = DBSTATUS_E_CANTCONVERTVALUE; } } else { Win4Assert( (rDstBinding.Binding().wType & DBTYPE_BYREF) || (rDstBinding.Binding().wType == DBTYPE_BSTR) );
if ( DBTYPE_VARIANT == vtSrc ) { CTableVariant & varnt = * ( (CTableVariant *) pbSrcData );
tbDebugOut(( DEB_ACCESSOR, "byref non-vector copy, vtDst 0x%x, varnt.vt 0x%x\n", vtDst, varnt.vt ));
if ((rDstBinding.Binding().wType & ~DBTYPE_BYREF) == DBTYPE_VARIANT) { // Just return a pointer to the stored variant
* (VARIANT **) pbDstData = (VARIANT *) pbSrcData; } else if ( ( varnt.VariantPointerInFirstWord() ) && ( isEquivalentType( vtDst, varnt.vt ) ) ) { // Grab the pointer value out of the variant; any ptr will do
* ( (LPWSTR *) pbDstData ) = varnt.pwszVal;
// Make a variant in case length is bound for this column
rSrcVar.vt = varnt.vt; rSrcVar.pwszVal = varnt.pwszVal; } else { * ( (LPWSTR *) pbDstData ) = 0; DstStatus = NullOrCantConvert( varnt.vt ); } } else { // The constructor verified everything is fine -- copy the ptr
* (void **) pbDstData = * (void **) pbSrcData;
// Make a variant in case length is bound for this column
rSrcVar.vt = vtSrc; rSrcVar.pwszVal = * (WCHAR **) pbSrcData; } }
if ( rSrcColumn.IsNull( pbSrc ) ) { tbDebugOut(( DEB_ITRACE, "byref column status IsNull\n" )); DstStatus = DBSTATUS_S_ISNULL; } return DstStatus;} //_ByRefCopy
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessor::_CopyColumn, private
//
// Synopsis: Return a set of row data to the caller
//
// Arguments: [pbDst] -- destination row buffer
// [rDstBinding] -- binding for the destination
// [pbSrc] -- source row buffer
// [rSrcColumn] -- source column description
// [rSrcSet] -- set of source columns
// [iColumn] -- column being copied
// [rRowBuffer] -- row buffer
// [hrow] -- hrow being retrieved
// [xDataConvert] -- smart pointer to IDataConvert interface.
// this is to be passed along and used finally
// in COLEDBVariant::CopyOrCoerce
//
// Returns: DBSTATUS -- status of the column copy
//
// History: 21 Nov 1994 dlee created
// 09 Jan 1998 vikasman added xDataConvert parameter
//
//--------------------------------------------------------------------------
DBSTATUS CRowDataAccessor::_CopyColumn( BYTE * pbDst, CDataBinding & rDstBinding, BYTE * pbSrc, CTableColumn & rSrcColumn, CTableColumnSet & rSrcSet, DBORDINAL iColumn, CRowBuffer & rRowBuffer, HROW hrow, XInterface<IDataConvert>& xDataConvert){ DBSTATUS DstStatus = DBSTATUS_S_OK; DBLENGTH cbDstLength = 0; CTableVariant varLen; BOOL fVariantValid = FALSE; BOOL fLengthValid = FALSE; BOOL fStatusValid = FALSE;
// pull out the data types for clarity below
VARTYPE vtDst = (VARTYPE) rDstBinding.Binding().wType; VARTYPE vtSrc = rSrcColumn.GetStoredType();
if (DBPART_VALUE & rDstBinding.Binding().dwPart) { // the row buffer promises NOT to set the byref bit for these.
// we'll break elsewhere if this is not true.
Win4Assert(vtSrc != ( VT_LPWSTR | VT_BYREF ) ); Win4Assert(vtSrc != ( VT_LPSTR | VT_BYREF ) );
BYTE *pbSrcData = pbSrc + rSrcColumn.GetValueOffset(); BYTE *pbDstData = pbDst + rDstBinding.Binding().obValue;
tbDebugOut(( DEB_ACCESSOR, "copying column %d, vtsrc 0x%x, vtdst 0x%x\n", iColumn, vtSrc, vtDst ));
// vpath can be null if not an IIS root
if ( ( iColumn == _iVpathBinding ) && ( !rSrcColumn.IsNull( pbSrc ) ) ) { Win4Assert(VT_VARIANT == vtSrc || VT_LPWSTR == vtSrc || VT_BSTR == vtSrc); LPWSTR pwszPath = (LPWSTR) pbSrcData; if (VT_VARIANT == vtSrc) pwszPath = ((PROPVARIANT *)pbSrcData)->pwszVal; if (pwszPath) ConvertBackslashToSlash(pwszPath); }
if ( DBTYPE_IUNKNOWN == vtDst ) { DstStatus = _BindToObject( pbDstData, rDstBinding, pbSrc, rSrcColumn, rSrcSet ); } else { // Transfer a data value
USHORT cbData, cbAlignment, rgfFlags; CTableVariant::VartypeInfo(vtSrc, cbData, cbAlignment, rgfFlags);
if ( rSrcColumn.IsNull( pbSrc ) && (vtDst & DBTYPE_BYREF) == 0 ) { tbDebugOut(( DEB_ITRACE, "column %d status IsNull -> VT_EMPTY\n", iColumn ));
RtlZeroMemory( pbDstData, rDstBinding.GetMaxLen() ); DstStatus = DBSTATUS_S_ISNULL; } else if ( ( vtDst == vtSrc ) && ( vtDst != VT_VARIANT ) && ( 0 == (rgfFlags & CTableVariant::ByRef ) ) && ( 0 != (rgfFlags & CTableVariant::StoreDirect ) ) ) { // Data column equivalent and not indirect, so just copy it.
// Storage props (except filename/path) will do this.
cbDstLength = rSrcColumn.GetValueSize(); fLengthValid = TRUE; RtlCopyMemory( pbDstData, pbSrcData, cbDstLength ); } else if ( ( rDstBinding.Binding().dwMemOwner == DBMEMOWNER_PROVIDEROWNED ) && ( ! rSrcColumn.IsDeferred( pbSrc ) ) && ( ( vtDst & DBTYPE_BYREF ) || ( vtDst & DBTYPE_VECTOR ) || ( vtDst & VT_ARRAY ) || ( vtDst == DBTYPE_BSTR ) ) ) { // Efficiently bound filename/path, etc. will do this
DstStatus = _ByRefCopy( rDstBinding, pbSrc, rSrcColumn, vtSrc, varLen, pbSrcData, vtDst, pbDstData );
if ( DBSTATUS_S_OK == DstStatus ) rRowBuffer.SetByrefData( pbSrc ); fVariantValid = TRUE; } else if (vtDst == DBTYPE_BYTES && rDstBinding.GetMaxLen() > 1 && CTableVariant::TableIsStoredInline( rgfFlags, vtSrc )) { // Special case for small fixed-length fields
DBLENGTH cbCopy = rSrcColumn.GetValueSize(); if (rDstBinding.GetMaxLen() < cbCopy) { cbCopy = rDstBinding.GetMaxLen(); DstStatus = DBSTATUS_S_TRUNCATED; }
RtlCopyMemory(pbDstData, pbSrcData, cbCopy); cbDstLength = cbCopy; fLengthValid = TRUE; } else if (vtDst == DBTYPE_BYTES && rDstBinding.GetMaxLen() > 1 && vtSrc == VT_VARIANT) { // Special case for small fixed-length fields from a variant
CTableVariant * pVarnt = (CTableVariant *)pbSrcData; pVarnt->VartypeInfo(pVarnt->vt, cbData, cbAlignment, rgfFlags);
if (rgfFlags & CTableVariant::SimpleType) { DBLENGTH cbCopy = cbData; if (rDstBinding.GetMaxLen() < cbCopy) { cbCopy = rDstBinding.GetMaxLen(); DstStatus = DBSTATUS_S_TRUNCATED; } RtlCopyMemory(pbDstData, &(pVarnt->lVal), cbCopy); cbDstLength = cbCopy; fLengthValid = TRUE; } else { DstStatus = DBSTATUS_E_CANTCONVERTVALUE; } } else { // Copying to/from a variant or a coercion is required.
DstStatus = _ComplexCopy( rDstBinding, pbSrc, rSrcColumn, iColumn, vtSrc, cbDstLength, pbSrcData, vtDst, pbDstData, rSrcSet, rRowBuffer, hrow, xDataConvert);
fLengthValid = TRUE; } }
// indicate status has been validated
fStatusValid = TRUE;
// bump the chapter reference count if we successfully transferred
// a chapter value
if ( DBSTATUS_S_OK == DstStatus && rDstBinding.IsChapter() ) rRowBuffer.ReferenceChapter( pbSrc ); }
// fill-in the length if the client asked for it
if (DBPART_LENGTH & rDstBinding.Binding().dwPart) { DBLENGTH *pcbDst = (DBLENGTH *) (pbDst + rDstBinding.Binding().obLength);
if ( ( DBSTATUS_S_ISNULL == DstStatus ) || ( DBSTATUS_E_CANTCONVERTVALUE == DstStatus ) || ( 0 != ( vtDst & DBTYPE_VECTOR ) ) ) // ole-db spec says so
{ *pcbDst = 0; } else if ( fLengthValid ) { *pcbDst = cbDstLength; } else if (! isVariableLength( vtDst ) ) { if ( vtDst & VT_BYREF ) { USHORT cbWidth, cbAlign, fFlags; CTableVariant::VartypeInfo( vtDst & ~VT_BYREF, cbWidth, cbAlign, fFlags );
*pcbDst = cbWidth; } else { *pcbDst = rDstBinding.GetMaxLen(); } } else { DBLENGTH cbLen = 0;
if (fVariantValid) { Win4Assert ( varLen.vt != VT_EMPTY ); cbLen = varLen.VarDataSize(); } else { //
// DBBINDING doesn't want DBPART_VALUE
//
SCODE sc = S_OK; ULONG cbDstBufNeeded = 0; DBTYPE dbtypeSrc; COLEDBVariant SrcVar;
BYTE *pbSrcData = pbSrc + rSrcColumn.GetValueOffset(); RtlCopyMemory( &SrcVar, pbSrcData, sizeof SrcVar ); SrcVar.GetDstLength( xDataConvert, rDstBinding.Binding().wType, cbLen ); }
// WSTR and STR lengths shouldn't include the terminating NULL
if ( (vtDst & VT_TYPEMASK) == DBTYPE_WSTR || vtDst == VT_LPWSTR ) cbLen -= sizeof (WCHAR); else if ( (vtDst & VT_TYPEMASK) == DBTYPE_STR || vtDst == VT_LPSTR ) cbLen -= sizeof (char); else if (vtDst == DBTYPE_BSTR) cbLen = sizeof (BSTR);
*pcbDst = cbLen; } }
if (! fStatusValid) { if ( rSrcColumn.IsStatusStored() && rSrcColumn.GetStatus( pbSrc ) == CTableColumn::StoreStatusNull ) DstStatus = DBSTATUS_S_ISNULL; }
if (DBPART_STATUS & rDstBinding.Binding().dwPart) { * (DBSTATUS *) (pbDst + rDstBinding.Binding().obStatus) = DstStatus; }
return DstStatus;} //_CopyColumn
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessor::GetData, public
//
// Synopsis: Copies data into the buffer as specified when the accessor
// was created
//
// Arguments: [hRow] -- row whose data is copied
// [pData] -- where data is written
// [rBufferSet] -- object useful for transforming an HROW
// into a buffer and a column layout
// [rQuery] -- query to use for this getdata
// [colInfo] -- info about the columns
// [xDataConvert] -- smart pointer to IDataConvert interface.
// this is to be passed along and used finally
// in COLEDBVariant::CopyOrCoerce
//
// History: 21 Nov 1994 dlee created
// 09 Jan 1998 vikasman added xDataConvert parameter
//
//--------------------------------------------------------------------------
void CRowDataAccessor::GetData( HROW hRow, void * pData, CRowBufferSet & rBufferSet, PQuery & rQuery, CColumnsInfo & colInfo, XInterface<IDataConvert>& xDataConvert){
if ( _idColInfo != colInfo.GetId() ) { // We have a different columnsInfo with which we must validate.
Validate( colInfo, 0 ); }
_pQuery = &rQuery; // query to be used for this data retrieval
// first find the source data buffer and its layout
CLock lock( rBufferSet.GetBufferLock() );
CTableColumnSet *pRowBufColSet; BYTE *pbSrc;
CRowBuffer &rRowBuffer = rBufferSet.Lookup( hRow, &pRowBufColSet, (void **) &pbSrc );
// now copy the data from the internal buffer to the user's buffer
ULONG cCopied = 0;
// We need to determine whether all the conversions failed or
// all of them succeeded or some failed/some passed
ULONG cSuccess = 0;
TRY { for ( cCopied = 0; cCopied < _cBindings; cCopied++ ) { CTableColumn *pSrcCol = rRowBuffer.Find( (ULONG) _aBindings[cCopied].GetDataColumn() );
if ( 0 == pSrcCol ) { // Somehow, the row buffer doesn't have a column that's in
// the accessor. This is an internal error.
Win4Assert(!"CRowDataAccessor::GetData couldn't find column binding"); }
DBSTATUS DstStatus = _CopyColumn( (BYTE *) pData, _aBindings[cCopied], pbSrc, *pSrcCol, *pRowBufColSet, cCopied, rRowBuffer, hRow, xDataConvert);
tbDebugOut(( DEB_ITRACE, "GetData column %d, status 0x%x\n", cCopied, DstStatus ));
// see if we have a coercion error. any other column status will
// not result in a special return code from GetData -- it's just
// reflected in the column status field (if the user asks for it)
if ( DBStatusOK( DstStatus ) ) { // Success
cSuccess++; } } } CATCH( CException, e ) { // fatal error -- free the data allocated so far for return to the
// client, then rethrow the error condition
for ( ULONG i = 0; i < cCopied; i++ ) if ( _aBindings[i].Binding().dwMemOwner != DBMEMOWNER_PROVIDEROWNED ) CTableVariant::Free( (BYTE *) pData + _aBindings[i].Binding().obValue, (VARTYPE) _aBindings[i].Binding().wType, _Pool );
RETHROW(); } END_CATCH;
if ( cSuccess == _cBindings ) // takes care of _cBindings == 0 case
{ // AllSuccess
; // do nothing
} else if ( cSuccess == 0 ) { // AllFail
QUIETTHROW( CException( DB_E_ERRORSOCCURRED ) ); } else { // SomeSuccess/SomeFail
QUIETTHROW( CException( DB_S_ERRORSOCCURRED ) ); }
} //GetData
//+-------------------------------------------------------------------------
//
// Member: CRowDataAccessorByRef::GetData, public
//
// Synopsis: Copies data into the buffer as specified when the accessor
// was created. For provider-owned memory with variant byref
// binding.
//
// Arguments: [hRow] -- row whose data is copied
// [pData] -- where data is written
// [rBufferSet] -- object useful for transforming an HROW
// into a buffer and a column layout
// [rQuery] -- query to use for this getdata
// [colInfo] -- info about the columns
// [xDataConvert] -- smart pointer to IDataConvert interface.
// this is to be passed along and used finally
// in COLEDBVariant::CopyOrCoerce
//
// History: 09 Apr 1996 dlee created
// 09 Jan 1998 vikasman added xDataConvert parameter
//
//--------------------------------------------------------------------------
void CRowDataAccessorByRef::GetData( HROW hRow, void * pData, CRowBufferSet & rBufferSet, PQuery & rQuery, CColumnsInfo & colInfo, XInterface<IDataConvert> & xDataConvert){ // we validated the column info on construction
Win4Assert ( _idColInfo == colInfo.GetId() );
// first find the source data buffer and its layout
CLock lock( rBufferSet.GetBufferLock() );
CTableColumnSet *pRowBufColSet; BYTE *pbSrc;
CRowBuffer &rRowBuffer = rBufferSet.Lookup( hRow, &pRowBufColSet, (void **) &pbSrc );
// now copy the data from the internal buffer to the user's buffer
for ( unsigned iCol = 0; iCol < _cBindings; iCol++ ) { CDataBinding & dstDataBinding = _aBindings[ iCol ]; CTableColumn & rSrcCol = * rRowBuffer.Find( (ULONG) dstDataBinding.GetDataColumn() );
Win4Assert( 0 != &rSrcCol && "CRowDataAccessorByRef::GetData couldn't find column binding");
BYTE *pbSrcData = pbSrc + rSrcCol.GetValueOffset(); DBBINDING & DstBinding = dstDataBinding.Binding();
Win4Assert( (DBTYPE_VARIANT|DBTYPE_BYREF) == DstBinding.wType || (DBTYPE_PROPVARIANT|DBTYPE_BYREF) == DstBinding.wType ); Win4Assert( DBPART_VALUE == DstBinding.dwPart ); Win4Assert( VT_VARIANT == rSrcCol.GetStoredType() );
PROPVARIANT **ppDstVar = (PROPVARIANT **) ( ( (BYTE*) pData ) + DstBinding.obValue );
if ( !rSrcCol.IsDeferred( pbSrc ) ) { // Convert '\' to '/' if this is the vpath.
// Vpath can be null if the file is not in an indexed IIS vroot.
if ( ( iCol == _iVpathBinding ) && ( !rSrcCol.IsNull( pbSrc ) ) ) { Win4Assert( VT_LPWSTR == ((PROPVARIANT *)pbSrcData)->vt || VT_BSTR == ((PROPVARIANT *)pbSrcData)->vt );
LPWSTR pwszPath = ((PROPVARIANT *)pbSrcData)->pwszVal; if (pwszPath) ConvertBackslashToSlash(pwszPath); }
*ppDstVar = (PROPVARIANT *) pbSrcData;
#if CIDBG==1
if ( rSrcCol.IsNull( pbSrc ) ) { Win4Assert( VT_EMPTY == (*ppDstVar)->vt ); } #endif // CIDBG==1
} else { // deferred copies can go through this slow code path
_pQuery = &rQuery; // query to be used for this data retrieval
DBLENGTH cbDstLen;
_ComplexCopy( _aBindings[iCol], pbSrc, rSrcCol, iCol, rSrcCol.GetStoredType(), cbDstLen, pbSrcData, DBTYPE_PROPVARIANT | DBTYPE_BYREF, (BYTE *) ppDstVar, *pRowBufColSet, rRowBuffer, hRow, xDataConvert); }
// bump the chapter reference count if we transferred
// a chapter value
if ( dstDataBinding.IsChapter() ) rRowBuffer.ReferenceChapter( pbSrc ); } rRowBuffer.SetByrefData( pbSrc );} //GetData
//+-------------------------------------------------------------------------
//
// Function: CreateAnAccessor
//
// Synopsis: Creates an accessor object deriving from CAccessor that is
// best-suited to handling the binding flags.
//
// Arguments: [dwAccessorFlags] -- read/write access requested
// [cBindings] -- # of bindings in rgBindings
// [rgBindings] -- array of bindings
// [rgBindStatus] -- array of binding statuses
// [fExtTypes] -- TRUE if extended variants are supported
// [pColumns] -- column info, may be 0
//
// History: 9 Apr 96 dlee created
//
//--------------------------------------------------------------------------
CAccessor * CreateAnAccessor( DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings, const DBBINDING * rgBindings, DBBINDSTATUS * rgBindStatus, BOOL fExtTypes, void * pCreator, CColumnsInfo * pColumns ){ BOOL fByRefCandidate = TRUE;
// CRowDataAccessorByRef candidates must:
// - have a non-0 pColumns
// - allow extended variant types (PROPVARIANT)
// - only bind to VALUE, not STATUS or LENGTH
// - only bind as DBTYPE_PROPVARIANT or DBTYPE_VARIANT byref
// - only bind with DBMEMOWNER_PROVIDEROWNED
//
// Accessors that don't meet these criteria go through the slower
// CRowDataAccessor.
if ( ( 0 == pColumns ) || ( dwAccessorFlags != DBACCESSOR_ROWDATA ) || ! fExtTypes ) fByRefCandidate = FALSE;
for ( DBORDINAL iBinding = 0; fByRefCandidate && iBinding < cBindings; iBinding++ ) { DBBINDING const & b = rgBindings[ iBinding ];
if ( b.dwPart != DBPART_VALUE || b.dwMemOwner != DBMEMOWNER_PROVIDEROWNED || (( b.wType != (DBTYPE_PROPVARIANT|DBTYPE_BYREF) ) && (! fExtTypes || b.wType != (DBTYPE_VARIANT|DBTYPE_BYREF) ) ) ) fByRefCandidate = FALSE; }
tbDebugOut(( DEB_ITRACE, "accessor can be byref: %d\n", fByRefCandidate ));
if ( fByRefCandidate ) return new CRowDataAccessorByRef( dwAccessorFlags, cBindings, rgBindings, rgBindStatus, TRUE, pCreator, pColumns );
return new CRowDataAccessor( dwAccessorFlags, cBindings, rgBindings, rgBindStatus, fExtTypes, pCreator, pColumns );} //CreateAnAccessor
|
