|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: TableCol.cxx
//
// Contents: Large table column descriptors
//
// Classes: CTableColumn
// CTableColumnArray
// CTableColumnSet
//
// History: 15 Sep 94 AlanW Split from coldesc.cxx
//
//--------------------------------------------------------------------------
#include "pch.cxx"
#pragma hdrstop
#include <tablecol.hxx>
#include <tblvarnt.hxx>
#include "colcompr.hxx"
#include "tabledbg.hxx"
#include "pathstor.hxx"
IMPL_DYNARRAY( CTableColumnArray, CTableColumn );
//+-------------------------------------------------------------------------
//
// Member: CTableColumn::~CTableColumn, public
//
// Synopsis: Destructor for a table column description.
//
// Notes:
//
//--------------------------------------------------------------------------
CTableColumn::~CTableColumn( ){ if (_pCompression && !_fGlobalCompr && _CompressMasterID == 0) delete _pCompression;}
//+-------------------------------------------------------------------------
//
// Member: CTableColumnSet::Add, public
//
// Synopsis: Add a column description to a column set.
//
// Arguments: [pCol] - a smart pointer to column to be added.
// [iCol] - position in array to use.
//
// Returns: Nothing
//
// Notes: Care is taken to assure that the smart pointer is
// transferred to the column array without generating
// an exception while holding the bare pointer.
//
//--------------------------------------------------------------------------
voidCTableColumnSet::Add( XPtr<CTableColumn> & pCol, unsigned iCol) { if (iCol >= Size()) CTableColumnArray::Add(0, iCol); // probe to expand array
CTableColumnArray::Add(pCol.Acquire(), iCol); if (iCol >= Count()) { Win4Assert(iCol == Count()); SetCount(iCol+1); }}
// CLEANCODE - old version, delete me someday
voidCTableColumnSet::Add( CTableColumn* pCol, unsigned iCol) { CTableColumnArray::Add(pCol, iCol); if (iCol >= Count()) { Win4Assert(iCol == Count()); SetCount(iCol+1); }}
//+-------------------------------------------------------------------------
//
// Member: CTableColumnSet::Find, public
//
// Synopsis: Find a particular column in a column array
//
// Arguments: [PropId] - property ID to search for
// [rfFound] - reference to flag, set to TRUE if match found
//
// Returns: CTableColumn* - pointer to the column found, or zero
//
// Notes:
//
//--------------------------------------------------------------------------
CTableColumn *CTableColumnSet::Find( PROPID const PropId, BOOL& rfFound) const { for (unsigned i=0; i<Count(); i++) { CTableColumn* pCol = Get(i); if (pCol && pCol->PropId == PropId) { rfFound = TRUE; return pCol; } } rfFound = FALSE; return 0;}
//+-------------------------------------------------------------------------
//
// Member: CTableColumnSet::Marshall, public
//
// Synopsis: Serialize a table column set
//
// Arguments: [stm] - serialization stream
// [pids] - CPidMapper to convert propids for propspecs
//
// Returns: Nothing
//
//--------------------------------------------------------------------------
void CTableColumnSet::Marshall( PSerStream & stm, CPidMapper & pids) const { stm.PutULong(Count());
for (unsigned i = 0; i < Count(); i++) Get(i)->Marshall( stm, pids );}
//+-------------------------------------------------------------------------
//
// Member: CTableColumn::Marshall, public
//
// Synopsis: Serialize a table column
//
// Arguments: [stm] - serialization stream
// [pids] - CPidMapper to convert propids for propspecs
//
// Returns: Nothing
//
//--------------------------------------------------------------------------
void CTableColumn::Marshall( PSerStream & stm, CPidMapper & pids) const { pids.PidToName(PropId)->Marshall( stm );
stm.PutULong(GetStoredType());
if ( 0 == IsValueStored() ) stm.PutByte( FALSE ); else { stm.PutByte( TRUE ); stm.PutUShort( GetValueOffset() ); stm.PutUShort( GetValueSize() ); }
if ( 0 == IsStatusStored() ) stm.PutByte( FALSE ); else { stm.PutByte( TRUE ); stm.PutUShort( GetStatusOffset() ); // stm.PutUShort( GetStatusSize() );
}
if ( 0 == IsLengthStored() ) stm.PutByte( FALSE ); else { stm.PutByte( TRUE ); stm.PutUShort( GetLengthOffset() ); // stm.PutUShort( GetLengthSize() );
}}
//+-------------------------------------------------------------------------
//
// Member: CTableColumnSet::CTableColumnSet, public
//
// Synopsis: Construct a table column set from a serialized stream
//
// Arguments: [stm] - serialization stream
// [pids] - CPidMapper to convert propspecs to fake pids
//
// Returns: Nothing
//
//--------------------------------------------------------------------------
CTableColumnSet::CTableColumnSet( PDeSerStream & stm, CPidMapper & pidmap ) : _cColumns(0), CTableColumnArray( 0 ){ ULONG cItems = stm.GetULong();
// Guard against attack
if ( cItems > 1000 ) THROW( CException( E_INVALIDARG ) );
SetExactSize( cItems );
for ( unsigned i = 0; i < cItems; i++ ) { CFullPropSpec prop( stm ); if ( !prop.IsValid() ) THROW( CException( E_OUTOFMEMORY ) );
PROPID pid = pidmap.NameToPid( prop ); XPtr<CTableColumn> Col( new CTableColumn( pid ) );
DBTYPE DataType = (USHORT) stm.GetULong();
//
// Only support VT_VARIANT and VT_I4 bindings. Other ones aren't
// tested or officially supported -- our OLE DB client only uses
// these two. Other datatypes are probably a hacker.
//
if ( VT_I4 == DataType ) { // VT_I4 must be workid
if ( ! ( ( prop.IsPropertyPropid() ) && ( prop.GetPropertyPropid() == PROPID_QUERY_WORKID ) && ( prop.GetPropSet() == PSGUID_QUERY ) ) ) THROW( CException( E_INVALIDARG ) ); } else if ( VT_VARIANT != DataType ) THROW( CException( E_INVALIDARG ) );
if ( TRUE == stm.GetByte() ) { USHORT usOffset = stm.GetUShort();
// Check for a bogus offset
if ( usOffset > 0x1000 ) THROW( CException( E_INVALIDARG ) );
// validate the offset
Col->SetValueField ( DataType, usOffset, stm.GetUShort() ); }
if ( TRUE == stm.GetByte() ) { USHORT usOffset = stm.GetUShort();
// Check for a bogus offset
if ( usOffset > 0x1000 ) THROW( CException( E_INVALIDARG ) );
Col->SetStatusField ( usOffset, sizeof (BYTE) ); }
if ( TRUE == stm.GetByte() ) { USHORT usOffset = stm.GetUShort();
// Check for a bogus offset
if ( usOffset > 0x1000 ) THROW( CException( E_INVALIDARG ) );
Col->SetLengthField ( usOffset, sizeof (ULONG) ); }
Add( Col.Acquire(), i); }}
//+---------------------------------------------------------------------------
//
// Function: _IsSpecialPathProcessing
//
// Synopsis: Tests if the column is a candidate for doing special path
// processing or not.
//
// Arguments: [dstColumn] - The column into which the data must be copied
// in the destination row.
//
// Returns: TRUE if special path processing can be done.
// FALSE o/w
//
// History: 5-23-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
inlineBOOLCTableColumn::_IsSpecialPathProcessing( CTableColumn const & dstColumn ) const{ VARTYPE vtDst = dstColumn.GetStoredType();
return ( pidPath == PropId || pidName == PropId ) && ( vtDst == VT_LPWSTR ) && ( _StoreAsType == VT_LPWSTR ) && ( _pCompression != 0);}
//+---------------------------------------------------------------------------
//
// Function: _GetPathOrFile
//
// Synopsis: Fetches the path or file (if possible) using special processing
// in the path store (if possible).
//
// Arguments: [dstColumn] - Destination column into which the data is
// being copied.
// [pbSrc] - The source window row.
// [rDstPool] - Var allocator for destination variable memory
// allocation.
// [pbDstRow] - Pointer to the destination row.
//
// Returns: TRUE if the pidName/pidPath could be fetched. FALSE o/w.
//
// History: 5-23-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
BOOL CTableColumn::_GetPathOrFile( CTableColumn const & dstColumn, const BYTE * pbSrc, PVarAllocator & rDstPool, BYTE * pbDstRow ){ const BYTE * pbSrcOrg = pbSrc;
CPathStore * pSrcPathStore = 0; if ( 0 != _pCompression ) { pSrcPathStore = _pCompression->GetPathStore(); }
if ( 0 == pSrcPathStore ) return FALSE;
// tbDebugOut(( DEB_ITRACE, "Special Path Processing\n" ));
//
// We have a path store.
//
Win4Assert( GetValueSize() == sizeof(PATHID) ); pbSrc += GetValueOffset();
PATHID srcPathId; RtlCopyMemory( &srcPathId, pbSrc, sizeof(PATHID) );
BOOL fDone = FALSE;
if ( !dstColumn.IsCompressedCol() ) { //
// Extract the path/file out of the path store for this pathid.
//
WCHAR * pwszDest = pSrcPathStore->Get( srcPathId, PropId, rDstPool ); if ( 0 != pwszDest ) {
ULONG_PTR offset = rDstPool.PointerToOffset( pwszDest ); Win4Assert( dstColumn.GetValueSize() == sizeof(ULONG) );
RtlCopyMemory( pbDstRow + dstColumn.GetValueOffset(), &offset, dstColumn.GetValueSize() );
Win4Assert( dstColumn.IsStatusStored() ); dstColumn.SetStatus( pbDstRow, GetStatus( pbSrcOrg ) );
if ( dstColumn.IsLengthStored() ) { ULONG *pulLength = (ULONG *) (pbDstRow + dstColumn.GetLengthOffset());
*pulLength = (ULONG) (wcslen( pwszDest ) + 1 ) * sizeof(WCHAR); }
fDone = TRUE; } } else { //
// The destination column is compressed. See if it
// also has a path store and copy to it.
//
Win4Assert( dstColumn.IsValueStored() );
//
// Copy the data to the target.
//
if ( 0 == dstColumn.GetCompressMasterId() ) { Win4Assert( dstColumn.IsStatusStored() ); dstColumn.SetStatus( pbDstRow, GetStatus( pbSrcOrg ) );
CPathStore * pDstPathStore = dstColumn.GetCompressor()->GetPathStore();
ULONG* pulRowColDataBuf = dstColumn.GetValueSize() ? (ULONG*) (pbDstRow + dstColumn.GetValueOffset()) : 0;
Win4Assert( 0 != pulRowColDataBuf );
if ( 0 != pDstPathStore ) { *pulRowColDataBuf = pDstPathStore->AddPath( *pSrcPathStore, srcPathId ); fDone = TRUE; } } else { //
// This is shared compression. There is nothing to store for this
// column.
//
fDone = TRUE; } }
return fDone;}
//+-------------------------------------------------------------------------
//
// Member: CTableColumn::CopyColumnData, public
//
// Synopsis: Copy a column's data fields between two row buffers.
// Coercion of the data can occur for data transfer to
// the user.
//
// Arguments: [pbDstRow] -- destination row buffer
// [rDstColumn] -- destination column description
// [rDstPool] -- destination variable data allocator
// [pbSrcRow] -- source row buffer
// [rSrcPool] -- source variable data allocator
//
// Returns: DBSTATUS -- status of the column copy
//
// History: 22 Feb 1995 AlanW Created
//
//--------------------------------------------------------------------------
DBSTATUS CTableColumn::CopyColumnData( BYTE * pbDstRow, CTableColumn const & rDstColumn, PVarAllocator & rDstPool, BYTE * pbSrcRow, PVarAllocator & rSrcPool){ DBSTATUS DstStatus = DBSTATUS_S_OK;
// pull out the data types for clarity below
VARTYPE vtDst = rDstColumn.GetStoredType(); VARTYPE vtSrc = GetStoredType();
#if 0
if (rDstColumn.IsValueStored())#endif
{
Win4Assert( IsValueStored() );
// 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 ) );
Win4Assert( 0 == ( VT_VECTOR & vtDst ) );
// Transfer a data value
if ( ( vtDst == vtSrc ) && ( CTableVariant::IsSimpleType( vtDst ) ) && ! IsCompressedCol() && ! rDstColumn.IsCompressedCol() ) { // Data columns equivalent, and not indirect. Just
// copy from source to dest.
Win4Assert( rDstColumn.IsStatusStored() ); rDstColumn.SetStatus( pbDstRow, GetStatus( pbSrcRow ) );
#if CIDBG == 1 || DBG == 1
USHORT cbData, cbAlignment, rgfFlags; CTableVariant::VartypeInfo(vtSrc, cbData, cbAlignment, rgfFlags);
Win4Assert( CTableVariant::TableIsStoredInline( rgfFlags, vtSrc ) ); Win4Assert( rDstColumn.GetValueSize() == GetValueSize() && cbData == GetValueSize());
#endif // CIDBG == 1 || DBG == 1
RtlCopyMemory( pbDstRow + rDstColumn.GetValueOffset(), pbSrcRow + GetValueOffset(), GetValueSize());
// performance: we never bind to length for these fixed-length
// fields.
Win4Assert( !rDstColumn.IsLengthStored() );
//if (rDstColumn.IsLengthStored())
// rDstColumn.SetLength( pbDstRow, rDstColumn.GetValueSize() );
} else {
//
// Check if this is "pidPath"/ "pidName" and if the destination
// allows special path processing.
//
if ( !_IsSpecialPathProcessing(rDstColumn) || !_GetPathOrFile( rDstColumn, pbSrcRow, rDstPool, pbDstRow ) ) { if ( ( vtDst == VT_LPWSTR || vtDst == ( DBTYPE_WSTR | DBTYPE_BYREF ) ) && vtSrc == VT_LPWSTR && !IsCompressedCol() && !rDstColumn.IsCompressedCol() ) { //
// Optimized path for the common case of wide string -> wide string
// copy, such as paths and filenames
//
BYTE *pbSrc = pbSrcRow + GetValueOffset();
WCHAR *pszValue = *(WCHAR **) pbSrc;
BYTE *pbDestBuf = pbDstRow + rDstColumn.GetValueOffset(); Win4Assert( (ULONG_PTR) pbDestBuf % 4 == 0 );
if ( pszValue ) { ULONG cbSrc = ( wcslen(pszValue) + 1 ) * sizeof( WCHAR ); BYTE *pbDest = (BYTE *) rDstPool.CopyTo( cbSrc, (BYTE *) pszValue ); *(BYTE **) pbDestBuf = (BYTE *) rDstPool.PointerToOffset( pbDest ); } else { *(ULONG *) pbDestBuf = 0; }
Win4Assert( !rDstColumn.IsLengthStored() );
#if 0
if ( rDstColumn.IsLengthStored() ) { ULONG *pulLength = (ULONG *) pbDstRow + rDstColumn.GetLengthOffset(); *pulLength = GetValueSize(); }
#endif // 0
} else { //
// For any other case, convert to a CTableVariant, then
// copy it using the CopyOrCoerce method. This allows
// coercions and variant to nonvariant, etc. conversions
// to occur.
//
// NOTE: We may want to optimize the PROPVARIANT to PROPVARIANT
// case when offsets are used in both source and
// destination, since this will occur commonly in
// table splits and row fetches.
//
CTableVariant varnt; XCompressFreeVariant xpVarnt;
if ( CreateVariant(varnt, pbSrcRow, rSrcPool) ) xpVarnt.Set(GetCompressor(), &varnt);
if ( rDstColumn.IsCompressedCol() ) { Win4Assert( rDstColumn.IsValueStored() && ! rDstColumn.IsLengthStored() );
//
// Copy the data to the target.
//
if (0 == rDstColumn.GetCompressMasterId()) { ULONG* pulRowColDataBuf = rDstColumn.GetValueSize() ? (ULONG*) (pbDstRow + rDstColumn.GetValueOffset()) : 0; GetValueResult eGvr;
rDstColumn.GetCompressor()->AddData( &varnt, pulRowColDataBuf, eGvr); Win4Assert( eGvr == GVRSuccess ); } } else { DBLENGTH ulTemp; DstStatus = varnt.CopyOrCoerce( pbDstRow + rDstColumn.GetValueOffset(), rDstColumn.GetValueSize(), vtDst, ulTemp, rDstPool); }
if (rDstColumn.IsLengthStored()) { ULONG *pulLength = (ULONG *) (pbDstRow + rDstColumn.GetLengthOffset());
if (rDstColumn.GetStoredType() == VT_VARIANT) { USHORT flags,cbWidth,cbAlign; CTableVariant::VartypeInfo( varnt.vt, cbWidth, cbAlign, flags ); if ( CTableVariant::TableIsStoredInline( flags, varnt.vt ) ) *pulLength = (ULONG) cbWidth; else *pulLength = (ULONG) varnt.VarDataSize(); } else { // PERFFIX - CopyOrCorece should supply the output length!
*pulLength = GetValueSize(); } } } }
Win4Assert( rDstColumn.IsStatusStored() ); Win4Assert( IsStatusStored() );
rDstColumn.SetStatus( pbDstRow, GetStatus( pbSrcRow ) ); }
tbDebugOut(( DEB_ITRACE, "ColumnStatus: 0x%x\n", rDstColumn.GetStatus( pbDstRow ) )); }#if 0 // we never bind to size/length and NOT bind to value
else { //
// Destination doesn't need value, check to see if it needs the
// length or status. Get it from the input if it's there.
// Assert if the required value is not there.
//
// NOTE: These values will be valid only for a DBTYPE_VARIANT
// result.
//
if (rDstColumn.IsLengthStored()) { Win4Assert(VT_VARIANT == rDstColumn.GetStoredType()); ULONG *pulLength = (ULONG *) (pbDstRow + rDstColumn.GetLengthOffset());
if (IsLengthStored()) *pulLength = *(ULONG *) (pbSrcRow + GetLengthOffset()); else { Win4Assert(IsValueStored());
CTableVariant varnt; XCompressFreeVariant xpVarnt;
if ( CreateVariant(varnt, pbSrcRow, rSrcPool) ) xpVarnt.Set(GetCompressor(), &varnt);
USHORT flags,cbWidth,cbAlign; CTableVariant::VartypeInfo( varnt.vt, cbWidth, cbAlign, flags ); if ( CTableVariant::TableIsStoredInline( flags, varnt.vt ) ) *pulLength = (ULONG) cbWidth; else *pulLength = (ULONG) varnt.VarDataSize(); } }
// fill-in the column status
Win4Assert( rDstColumn.IsStatusStored() ); Win4Assert( IsStatusStored() );
rDstColumn.SetStatus( pbDstRow, GetStatus( pbSrcRow ) ); }#endif // 0: we never bind to size/length and NOT bind to value
return DstStatus;} //CopyColumn
//+-------------------------------------------------------------------------
//
// Member: CTableColumn::CreateVariant, public
//
// Synopsis: Create a table variant from a source column.
//
// Arguments: [rVarnt] -- reference to variant structure to be filled
// [pbSrc] -- source row buffer
// [rSrcPool] -- source variable data allocator
//
// Returns: BOOL -- TRUE if variant needs to be freed by
// column compressor.
//
// Notes: CLEANCODE - Should this routine take an XCompressFreeVariant as an
// input parameter to guard against memory leaks? An
// argument against is that HROW buffers would never
// be compressed, and don't need to know about column
// compressors.
//
// History: 22 Feb 1995 AlanW Created
//
//--------------------------------------------------------------------------
BOOL CTableColumn::CreateVariant( CTableVariant & rVarnt, BYTE * pbSrc, PVarAllocator & rSrcPool) const { //
// Advance the row buffer pointer to the stored value data.
//
Win4Assert(IsValueStored()); BYTE * pbSrcRow = pbSrc; pbSrc += GetValueOffset();
if ( IsCompressedCol() ) { GetValueResult eGvr = GetCompressor()->GetData( &rVarnt, GetStoredType(), GetValueSize()? *((ULONG *) (pbSrc)): 0, PropId); if ( GVRSuccess != eGvr ) { rVarnt.vt = VT_EMPTY; }
//
// Set up to free the variant when we're done with it.
//
return TRUE; } else { //
// There is no compression.
//
if (VT_VARIANT == GetStoredType()) { Win4Assert(GetValueSize() == sizeof PROPVARIANT); rVarnt = *((CTableVariant *) (pbSrc)); } else { if ( IsNull( pbSrcRow ) ) rVarnt.vt = VT_EMPTY; else rVarnt.Init( GetStoredType(), pbSrc, GetValueSize() ); }
if ( rVarnt.VariantPointerInFirstWord() && GetStoredType() != VT_CLSID) // already stored as pointer
{ if (0 == rVarnt.pszVal) { rVarnt.vt = VT_EMPTY; tbDebugOut(( DEB_WARN, "null indirect value for propid %d\n", PropId )); } else { rVarnt.pszVal = (LPSTR) rSrcPool.OffsetToPointer((ULONG_PTR)rVarnt.pszVal); } } else if (rVarnt.VariantPointerInSecondWord()) { if (0 == rVarnt.blob.pBlobData) { rVarnt.vt = VT_EMPTY; tbDebugOut(( DEB_WARN, "null indirect value for propid %d\n", PropId )); } else { rVarnt.blob.pBlobData = (BYTE *) rSrcPool.OffsetToPointer((ULONG_PTR)rVarnt.blob.pBlobData); } } } // no compression
return FALSE;} // CreateVariant
|
