|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: dbcmdbas.cxx
//
// Contents: Wrapper classes for DBCOMMANDTREE
//
// Classes: CDbCmdTreeNode
// CDbColumnNode
//
// History: 6-06-95 srikants Created
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <sstream.hxx>
const GUID CDbCmdTreeNode::guidNull = DB_NULLGUID;
inline BOOL IsNotImplemented( WORD wKind ){ return (wKind & DBVALUEKIND_VECTOR) || (wKind & DBVALUEKIND_ARRAY);}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::PutWString, static public
//
// Synopsis: Marshal a wide charater string.
//
// Arguments: [stm] - Serialization stream
// [pwszStr] - String to be serialized
//
// Returns: -NOTHING-
//
// History: 6-21-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::PutWString( PSerStream & stm, WCHAR const * pwszStr ){ ULONG cwc = (0 != pwszStr) ? wcslen( pwszStr ) : 0;
stm.PutULong( cwc ); if (cwc) stm.PutWChar( pwszStr, cwc );}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::GetWString, static public
//
// Synopsis: Unmarshal a wide character string.
//
// Arguments: [stm] - Deserialization stream
// [fSuccess] - On return, TRUE if string allocation was successful
// [fBstr] - TRUE if output string should be a BSTR
//
// Returns: WCHAR * - output string, can be null.
//
// History: 6-21-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
WCHAR * CDbCmdTreeNode::GetWString( PDeSerStream & stm, BOOL & fSuccess, BOOL fBstr ){ ULONG cwc = stm.GetULong();
// Guard against attack
if ( cwc >= 65536 ) { fSuccess = FALSE; return 0; }
fSuccess = TRUE;
if ( 0 == cwc ) { return 0; }
WCHAR * pwszStr = 0; if (fBstr) { pwszStr = (WCHAR *)SysAllocStringLen( L"", cwc ); } else { ULONG cb = (cwc+1) * sizeof(WCHAR); pwszStr = (WCHAR *) CoTaskMemAlloc( cb ); } if ( 0 == pwszStr ) { fSuccess = FALSE; return 0; }
stm.GetWChar( pwszStr, cwc ); pwszStr[cwc] = L'\0';
return pwszStr;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::AllocAndCopyWString, static public
//
// Synopsis:
//
// Arguments: [pSrc] -
//
// Returns:
//
// History: 6-22-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
WCHAR * CDbCmdTreeNode::AllocAndCopyWString( const WCHAR * pSrc ){ WCHAR * pDst = 0; if ( 0 != pSrc ) { const cb = ( wcslen( pSrc ) + 1 ) * sizeof(WCHAR); pDst = (WCHAR *) CoTaskMemAlloc( cb ); if ( 0 != pDst ) { RtlCopyMemory( pDst, pSrc, cb ); } }
return pDst;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::UnMarshallTree, static public
//
// Synopsis:
//
// Arguments: [stm] -
//
// Returns:
//
// History: 6-21-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
CDbCmdTreeNode * CDbCmdTreeNode::UnMarshallTree( PDeSerStream & stm ){ CDbCmdTreeNode * pRoot = new CDbCmdTreeNode(); if ( 0 != pRoot ) { if ( !pRoot->UnMarshall(stm) ) { delete pRoot; pRoot = 0; } }
return pRoot;}
void CDbCmdTreeNode::CleanupDataValue(){
if ( IsNotImplemented(wKind) ) { Win4Assert( !"Type Not Implemented" ); return; }
void * pMemToFree = 0;
//
// Deallocate any memory allocated for this node.
//
switch ( wKind ) { case DBVALUEKIND_EMPTY: break;
case DBVALUEKIND_WSTR: pMemToFree = (void *) value.pwszValue; break;
case DBVALUEKIND_BSTR: SysFreeString( (BSTR)value.pbstrValue ); break;
case DBVALUEKIND_COMMAND: if ( 0 != value.pCommand ) { value.pCommand->Release(); } break;
case DBVALUEKIND_IDISPATCH: if ( 0 != value.pDispatch ) { value.pDispatch->Release(); } break;
case DBVALUEKIND_MONIKER: if ( 0 != value.pMoniker ) { value.pMoniker->Release(); } break;
case DBVALUEKIND_ROWSET:
if ( 0 != value.pRowset ) { value.pRowset->Release(); } break;
case DBVALUEKIND_IUNKNOWN:
if ( 0 != value.pUnknown ) { value.pUnknown->Release(); } break;
case DBVALUEKIND_BYGUID:
if ( 0 != value.pdbbygdValue ) { delete ((CDbByGuid *) value.pdbbygdValue); } break;
case DBVALUEKIND_LIKE:
if ( 0 != value.pdblikeValue ) { delete ((CDbLike *) value.pdblikeValue); } break;
case DBVALUEKIND_COLDESC:
Win4Assert(! "DBVALUEKIND_COLDESC unsupported !"); break;
case DBVALUEKIND_ID:
if ( 0 != value.pdbidValue ) { delete ((CDbColId *) value.pdbidValue); } break;
case DBVALUEKIND_CONTENT:
if ( 0 != value.pdbcntntValue ) { delete ((CDbContent *) value.pdbcntntValue); } break;
case DBVALUEKIND_CONTENTPROXIMITY:
if ( 0 != value.pdbcntntproxValue ) { delete ((CDbContentProximity *) value.pdbcntntproxValue); } break;
case DBVALUEKIND_CONTENTSCOPE: if ( 0 != value.pdbcntntscpValue ) { delete ((CDbContentScope *) value.pdbcntntscpValue); } break;
case DBVALUEKIND_CONTENTTABLE: if ( 0 != value.pdbcntnttblValue ) { delete ((CDbContentTable *) value.pdbcntnttblValue); } break;
case DBVALUEKIND_CONTENTVECTOR:
if ( 0 != value.pdbcntntvcValue ) { delete ((CDbContentVector *) value.pdbcntntvcValue ); } break;
case DBVALUEKIND_GROUPINFO:
if ( 0 != value.pdbgrpinfValue ) { Win4Assert( !"NYI - DBVALUEKIND_GROUPINFO" ); delete ((CDbGroupInfo *) value.pdbgrpinfValue ); } break;
case DBVALUEKIND_PARAMETER:
if ( 0 != value.pdbparamValue ) { Win4Assert( !"NYI - DBVALUEKIND_PARAMETER" ); delete ((CDbParameter *) value.pdbparamValue ); } break;
case DBVALUEKIND_PROPERTY:
if ( 0 != value.pdbpropValue ) { Win4Assert( !"NYI - DBVALUEKIND_PROPERTY" ); delete ((CDbPropSet *) value.pdbpropValue); } break;
case DBVALUEKIND_SETFUNC:
if ( 0 != value.pdbstfncValue ) { Win4Assert( !"NYI - DBVALUEKIND_SETFUNC" ); // delete ((CDbSetFunc *) value.pdbstfncValue);
} break;
case DBVALUEKIND_SORTINFO:
if ( 0 != value.pdbsrtinfValue ) { delete ((CDbSortInfo *) value.pdbsrtinfValue); } break;
case DBVALUEKIND_TEXT:
if ( 0 != value.pdbtxtValue ) { Win4Assert( !"NYI - DBVALUEKIND_TEXT" ); delete ((CDbText *) value.pdbtxtValue ); } break;
case DBVALUEKIND_VARIANT:
if ( 0 != value.pvarValue ) { CStorageVariant * pVarnt = CastToStorageVariant( *value.pvarValue ); delete pVarnt; } break;
case DBVALUEKIND_GUID: pMemToFree = (void *) value.pGuid; break;
case DBVALUEKIND_BYTES: pMemToFree = (void *) value.pbValue; break;
case DBVALUEKIND_STR: pMemToFree = (void *) value.pzValue; break;
case DBVALUEKIND_NUMERIC: delete ((CDbNumeric *) value.pdbnValue ); break;
#if CIDBG==1
case DBVALUEKIND_BOOL: case DBVALUEKIND_UI1: case DBVALUEKIND_I1: case DBVALUEKIND_UI2: case DBVALUEKIND_I2: case DBVALUEKIND_I4: case DBVALUEKIND_UI4: case DBVALUEKIND_R4: case DBVALUEKIND_R8: case DBVALUEKIND_CY: case DBVALUEKIND_DATE: case DBVALUEKIND_ERROR: case DBVALUEKIND_I8: case DBVALUEKIND_UI8: break;
default: Win4Assert( !"Illegal Case Statement" );#endif // CIDBG==1
};
if ( 0 != pMemToFree ) { CoTaskMemFree( pMemToFree ); }
RtlZeroMemory( &value, sizeof(value) );}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::CDbCmdTreeNode, public
//
// Synopsis:
//
// Returns:
//
// History: 6-06-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
CDbCmdTreeNode::~CDbCmdTreeNode(){ //
// Unlink pointers before deleting, in case the caller gives
// a tree with cycles.
//
if ( 0 != pctFirstChild ) { CDbCmdTreeNode * pTree = (CDbCmdTreeNode *)pctFirstChild; pctFirstChild = 0; delete pTree; }
if ( 0 != pctNextSibling ) { CDbCmdTreeNode * pTree = GetNextSibling(); pctNextSibling = 0; while ( 0 != pTree) { CDbCmdTreeNode * pNext = pTree->GetNextSibling(); pTree->pctNextSibling = 0; delete pTree; pTree = pNext; } }
CleanupDataValue();}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::AppendChild, protected
//
// Synopsis: Add a node to the end of the child list.
//
// Arguments: [pChild] -
//
// Returns: Nothing
//
// History: 6-06-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::AppendChild( CDbCmdTreeNode *pChild ){ Win4Assert( 0 != pChild );
if ( 0 == pctFirstChild ) { pctFirstChild = pChild; } else { DBCOMMANDTREE * pCurr = pctFirstChild; while ( 0 != pCurr->pctNextSibling ) { pCurr = pCurr->pctNextSibling; }
pCurr->pctNextSibling = pChild; }}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::InsertChild, protected
//
// Synopsis: Add a node to the beginning of the child list.
//
// Arguments: [pChild] -
//
// Returns: Nothing
//
// History: 6-06-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::InsertChild( CDbCmdTreeNode *pChild ){ Win4Assert( 0 != pChild ); Win4Assert( 0 == pChild->pctNextSibling );
pChild->pctNextSibling = pctFirstChild; pctFirstChild = pChild;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::SetChildren, protected
//
// Synopsis: Add a list of nodes as children
//
// Arguments: [pChild] - head of list
//
// Returns: Nothing
//
// History: 23 Apr 1997 AlanW Created
//
// Notes: Could be inline if it weren't for the asserts
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::SetChildren( CDbCmdTreeNode *pChild ){ Win4Assert( 0 != pChild ); Win4Assert( 0 == pctFirstChild );
pctFirstChild = pChild;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::RemoveFirstChild, protected
//
// Synopsis: Unlink first child node and return it.
//
// Arguments: -NONE-
//
// Returns: First child node. NULL if no children.
//
// Notes:
//
// History: 13 July 1995 AlanW Created
//
//----------------------------------------------------------------------------
CDbCmdTreeNode * CDbCmdTreeNode::RemoveFirstChild( ){ CDbCmdTreeNode * pChild = (CDbCmdTreeNode *)pctFirstChild;
if (0 != pChild) { pctFirstChild = pChild->pctNextSibling; pChild->pctNextSibling = 0;
} return pChild;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::AppendSibling, protected
//
// Synopsis: Append a node to the end of the sibling list
//
// Arguments: [pSibling] - node to be added to the sibling list
//
// Returns: Nothing
//
// History: 6-13-95 srikants Created
//
// Notes: The pSibling may have siblings and children.
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::AppendSibling( CDbCmdTreeNode *pSibling ){ Win4Assert( 0 != pSibling );
if ( 0 == pctNextSibling ) { pctNextSibling = pSibling; } else { DBCOMMANDTREE * pCurr = pctNextSibling;
while ( 0 != pCurr->pctNextSibling ) { pCurr = pCurr->pctNextSibling; }
pCurr->pctNextSibling = pSibling; }}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::TransferNode, public
//
// Synopsis: Transfer pointers and data from one command tree node
// to another.
//
// Arguments: [pNode] - pointer to target node.
//
// Returns: nothing
//
// History: 27 Jun 1995 AlanW Created
//
// Notes: Specific to the needs of IQuery::AddPostProcessing;
// not available to client code.
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::TransferNode( CDbCmdTreeNode *pNode ){ RtlCopyMemory( pNode, this, sizeof(CDbCmdTreeNode)); RtlZeroMemory( this, sizeof(CDbCmdTreeNode) ); op = DBOP_DEFAULT; wKind = DBVALUEKIND_EMPTY;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::Clone, public
//
// Synopsis: Create a copy of a command tree
//
// Arguments: [fCopyErrors] - optional, TRUE if error fields are to be copied
//
// Returns: CdbCmdTreeNode* - the copy of the tree
//
// History: 6-13-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
CDbCmdTreeNode * CDbCmdTreeNode::Clone( BOOL fCopyErrors ) const{
if ( IsNotImplemented(wKind) ) { Win4Assert( !"Type Not Implemented" ); return 0; }
CDbCmdTreeNode * pCopy = new CDbCmdTreeNode( op );
if ( 0 == pCopy ) return 0;
if (fCopyErrors) pCopy->hrError = hrError; else pCopy->hrError = S_OK;
BOOL fSuccess = TRUE; pCopy->wKind = wKind;
switch ( wKind ) {
case DBVALUEKIND_EMPTY: break;
case DBVALUEKIND_BOOL: case DBVALUEKIND_UI1: case DBVALUEKIND_I1: case DBVALUEKIND_UI2: case DBVALUEKIND_I2: case DBVALUEKIND_I4: case DBVALUEKIND_UI4: case DBVALUEKIND_R4: case DBVALUEKIND_R8: case DBVALUEKIND_CY: case DBVALUEKIND_DATE: case DBVALUEKIND_ERROR: case DBVALUEKIND_I8: case DBVALUEKIND_UI8: //
// Just copy the eight bytes.
//
pCopy->value.llValue = value.llValue; break;
case DBVALUEKIND_WSTR:
if ( 0 != value.pwszValue ) { pCopy->value.pwszValue = AllocAndCopyWString( value.pwszValue ); fSuccess = 0 != pCopy->value.pwszValue; } break;
case DBVALUEKIND_BSTR:
if ( 0 != value.pbstrValue ) { *((BSTR*)&(pCopy->value.pbstrValue)) = SysAllocStringLen( (BSTR)value.pbstrValue, SysStringLen( (BSTR)value.pbstrValue ) ); fSuccess = ( 0 != pCopy->value.pbstrValue ); } break;
case DBVALUEKIND_COMMAND:
if ( 0 != value.pCommand ) { value.pCommand->AddRef(); pCopy->value.pCommand = value.pCommand; } break;
case DBVALUEKIND_IDISPATCH:
if ( 0 != value.pDispatch ) { value.pDispatch->AddRef(); pCopy->value.pDispatch = value.pDispatch; } break;
case DBVALUEKIND_MONIKER:
if ( 0 != value.pMoniker ) { value.pMoniker->AddRef(); pCopy->value.pMoniker = value.pMoniker; } break;
case DBVALUEKIND_ROWSET:
if ( 0 != value.pRowset ) { value.pRowset->AddRef(); pCopy->value.pRowset = value.pRowset; } break;
case DBVALUEKIND_IUNKNOWN:
if ( 0 != value.pUnknown ) { value.pUnknown->AddRef(); pCopy->value.pUnknown = value.pUnknown; } break;
case DBVALUEKIND_BYGUID:
if ( 0 != value.pdbbygdValue ) { CDbByGuid * pTemp = new CDbByGuid( *value.pdbbygdValue ); if ( 0 != pTemp ) { pCopy->value.pdbbygdValue = pTemp->CastToStruct(); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_COLDESC:
Win4Assert(! "DBVALUEKIND_COLDESC unsupported !"); break;
case DBVALUEKIND_ID:
if ( 0 != value.pdbidValue ) { CDbColId * pId = new CDbColId( *value.pdbidValue ); if ( 0 != pId ) { if ( !pId->IsValid() ) { delete pId; fSuccess = FALSE; } else pCopy->value.pdbidValue = pId->CastToStruct(); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENT:
if ( 0 != value.pdbcntntValue ) { CDbContent * pContent = new CDbContent( *value.pdbcntntValue ); if ( 0 != pContent ) { if ( !pContent->IsValid() ) { delete pContent; fSuccess = FALSE; } else pCopy->value.pdbcntntValue = (DBCONTENT *) pContent; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENTSCOPE:
if ( 0 != value.pdbcntntscpValue ) { CDbContentScope * pContentScp = new CDbContentScope( *value.pdbcntntscpValue ); if ( 0 != pContentScp ) { if ( !pContentScp->IsValid() ) { delete pContentScp; fSuccess = FALSE; } else pCopy->value.pdbcntntscpValue = (DBCONTENTSCOPE *) pContentScp; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENTTABLE:
if ( 0 != value.pdbcntnttblValue ) { CDbContentTable * pContentTbl = new CDbContentTable( *value.pdbcntnttblValue ); if ( 0 != pContentTbl ) { if ( !pContentTbl->IsValid() ) { delete pContentTbl; fSuccess = FALSE; } else pCopy->value.pdbcntnttblValue = (DBCONTENTTABLE *) pContentTbl; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENTVECTOR:
if ( 0 != value.pdbcntntvcValue ) { CDbContentVector * pTemp = new CDbContentVector( *value.pdbcntntvcValue ); if ( pTemp ) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdbcntntvcValue = pTemp->CastToStruct(); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENTPROXIMITY:
if ( 0 != value.pdbcntntproxValue ) { CDbContentProximity * pTemp = new CDbContentProximity( *value.pdbcntntproxValue ); if (pTemp) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdbcntntproxValue = pTemp->CastToStruct(); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_LIKE:
if ( 0 != value.pdblikeValue ) { CDbLike * pTemp = new CDbLike( *value.pdblikeValue ); if (pTemp) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdblikeValue = pTemp->CastToStruct(); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_GROUPINFO:
if ( 0 != value.pdbgrpinfValue ) { CDbGroupInfo * pTemp = new CDbGroupInfo( *value.pdbgrpinfValue ); if ( pTemp ) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdbgrpinfValue = (CDbGroupInfo *) pTemp; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_PARAMETER:
if ( 0 != value.pdbparamValue ) { CDbParameter * pTemp = new CDbParameter( *value.pdbparamValue ); if ( pTemp ) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdbparamValue = pTemp->CastToStruct(); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_PROPERTY:
if ( 0 != value.pdbpropValue ) { CDbPropSet * pTemp = new CDbPropSet( *value.pdbpropValue ); if ( 0 != pTemp ) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdbpropValue = pTemp->CastToStruct(); } else { fSuccess = FALSE; } }
break;
case DBVALUEKIND_SETFUNC:
Win4Assert( !"NYI - DBVALUEKIND_SETFUNC"); break;
case DBVALUEKIND_SORTINFO:
if ( 0 != value.pdbsrtinfValue ) { CDbSortInfo * pTemp = new CDbSortInfo( *value.pdbsrtinfValue ); if ( 0 != pTemp ) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdbsrtinfValue = (DBSORTINFO *) pTemp; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_TEXT:
if ( 0 != value.pdbtxtValue ) { CDbText * pTemp = new CDbText( *value.pdbtxtValue ); if ( pTemp ) { if ( !pTemp->IsValid() ) { delete pTemp; fSuccess = FALSE; } else pCopy->value.pdbtxtValue = (DBTEXT *) pTemp; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_VARIANT:
if ( 0 != value.pvarValue ) { CStorageVariant const * pSrcVarnt = CastToStorageVariant( *value.pvarValue ); CStorageVariant * pDstVarnt = new CStorageVariant( *pSrcVarnt ); fSuccess = ( 0 != pDstVarnt ) && pDstVarnt->IsValid();
if ( fSuccess ) pCopy->value.pvarValue = (VARIANT *) (void *) pDstVarnt; else delete pDstVarnt; } break;
case DBVALUEKIND_GUID:
if ( 0 != value.pGuid ) { GUID * pTemp = (GUID *) CoTaskMemAlloc( sizeof(GUID) ); if ( 0 != pTemp ) { *pTemp = *value.pGuid; pCopy->value.pGuid = pTemp; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_BYTES:
// how do we know the length of this ??
Win4Assert( !"NYI - DBVALUEKIND_BYTES" ); break;
case DBVALUEKIND_STR:
if ( 0 != value.pzValue ) { unsigned cb = strlen( value.pzValue ) + 1; char * pTemp = (char *) CoTaskMemAlloc( cb ); if ( pTemp ) { strcpy( pTemp, value.pzValue ); pCopy->value.pzValue = pTemp; } else { fSuccess = FALSE; } }
break;
case DBVALUEKIND_NUMERIC: Win4Assert( !"NYI - DBVALUEKIND_NUMERIC" ); break;
case DBVALUEKIND_BYREF: Win4Assert( !"NYI - DBVALUEKIND_BYREF" ); break;
default: Win4Assert( !"Invalid Case Statement" ); pCopy->wKind = DBVALUEKIND_EMPTY; }
if ( !fSuccess ) { delete pCopy; return 0; }
//
// Next allocate the children nodes
//
if ( 0 != pctFirstChild ) { CDbCmdTreeNode * pFirstChild = GetFirstChild(); pCopy->pctFirstChild = pFirstChild->Clone( fCopyErrors ); if ( 0 == pCopy->pctFirstChild ) { delete pCopy; return 0; } }
//
// Next allocate all the siblings.
// If stack space on the client becomes an issue we could iterate to
// reduce stack depth.
//
if ( 0 != pctNextSibling ) { CDbCmdTreeNode * pSibling = GetNextSibling(); pCopy->pctNextSibling = pSibling->Clone( fCopyErrors ); if ( 0 == pCopy->pctNextSibling ) { delete pCopy; return 0; } }
return pCopy;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::Marshall
//
// Synopsis:
//
// Arguments: [stm] -
//
// Returns:
//
// History: 6-20-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::Marshall( PSerStream & stm ) const{
if ( IsNotImplemented( wKind ) ) { Win4Assert( !"Type Not Implemented" ); return; }
//
// Serialize the operator
//
stm.PutULong( (ULONG) op );
//
// Indicate the kind of the value.
//
Win4Assert( sizeof(wKind) == sizeof(USHORT) ); stm.PutUShort( wKind );
//
// Serialize the hrError
//
Win4Assert( sizeof(hrError) == sizeof(hrError) ); stm.PutULong( hrError );
//
//
// Indicate if the child is null or not
//
if ( 0 != pctFirstChild ) { stm.PutByte(1); } else { stm.PutByte(0); }
//
// Indicate if the sibling is null or not
//
if ( 0 != pctNextSibling ) { stm.PutByte(1); } else { stm.PutByte(0); }
//
// Next serialize the value.
//
switch ( wKind ) { case DBVALUEKIND_EMPTY: break; // nothing to marshall
case DBVALUEKIND_BOOL: Win4Assert( sizeof(DBTYPE_BOOL) == sizeof(BYTE) ); case DBVALUEKIND_UI1: case DBVALUEKIND_I1: stm.PutByte( (BYTE) value.schValue ); break;
case DBVALUEKIND_UI2: case DBVALUEKIND_I2: stm.PutUShort( (USHORT) value.sValue ); break;
case DBVALUEKIND_I4: case DBVALUEKIND_UI4: stm.PutULong( (ULONG) value.ulValue ); break;
case DBVALUEKIND_R4: stm.PutFloat( value.flValue ); break;
case DBVALUEKIND_R8: stm.PutDouble( value.dblValue ); break;
case DBVALUEKIND_CY: case DBVALUEKIND_DATE: case DBVALUEKIND_ERROR: case DBVALUEKIND_I8: case DBVALUEKIND_UI8: stm.PutBlob( (BYTE *) &value, sizeof(value) ); break;
case DBVALUEKIND_WSTR: stm.PutWString( value.pwszValue ); break;
case DBVALUEKIND_BSTR: { ULONG cwc = (0 != value.pbstrValue) ? SysStringLen( (BSTR)value.pbstrValue ) : 0;
stm.PutULong( cwc ); if (cwc) stm.PutWChar( (BSTR)value.pbstrValue, cwc ); } break;
case DBVALUEKIND_COMMAND: case DBVALUEKIND_IDISPATCH: case DBVALUEKIND_MONIKER: case DBVALUEKIND_ROWSET: case DBVALUEKIND_IUNKNOWN: // How do you marshall an open interface?
stm.PutByte(0); break;
case DBVALUEKIND_BYGUID:
if ( value.pdbbygdValue ) { stm.PutByte(1); CDbByGuid * pTemp = (CDbByGuid *) value.pdbbygdValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_COLDESC:
Win4Assert(! "DBVALUEKIND_COLDESC unsupported !"); break;
case DBVALUEKIND_ID:
if ( value.pdbidValue ) { stm.PutByte(1); CDbColId * pTemp = (CDbColId *) value.pdbidValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_CONTENT:
if ( value.pdbcntntValue ) { stm.PutByte(1); CDbContent * pTemp = (CDbContent *) value.pdbcntntValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_CONTENTVECTOR:
if ( value.pdbcntntvcValue ) { stm.PutByte(1); CDbContentVector * pTemp = (CDbContentVector *)value.pdbcntntvcValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_LIKE:
if (value.pdblikeValue ) { stm.PutByte(1); CDbLike * pTemp = (CDbLike *)value.pdblikeValue; pTemp->Marshall( stm ); } else { stm.PutByte( 0 ); } break;
case DBVALUEKIND_CONTENTPROXIMITY:
if (value.pdbcntntproxValue ) { stm.PutByte(1); CDbContentProximity * pTemp = (CDbContentProximity *)value.pdbcntntproxValue; pTemp->Marshall( stm ); } else { stm.PutByte( 0 ); } break;
case DBVALUEKIND_GROUPINFO:
if ( value.pdbgrpinfValue ) { stm.PutByte(1); CDbGroupInfo * pTemp = (CDbGroupInfo *)value.pdbgrpinfValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_PARAMETER:
if ( value.pdbparamValue ) { stm.PutByte(1); CDbParameter * pTemp = (CDbParameter *)value.pdbparamValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_PROPERTY:
if ( value.pdbpropValue ) { stm.PutByte(1); CDbPropSet * pTemp = (CDbPropSet *)value.pdbpropValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_SETFUNC:
stm.PutByte(0); Win4Assert( !"NYI - DBVALUEKIND_SETFUNC" ); break;
case DBVALUEKIND_SORTINFO:
if ( value.pdbsrtinfValue ) { stm.PutByte(1); CDbSortInfo const * pSortInfo = (CDbSortInfo const *) value.pdbsrtinfValue; pSortInfo->Marshall( stm ); } else { stm.PutByte(0); }
break;
case DBVALUEKIND_TEXT:
if ( value.pdbtxtValue ) { stm.PutByte(1); CDbText * pTemp = (CDbText *) value.pdbtxtValue; pTemp->Marshall(stm); } else { stm.PutByte(0); } break;
case DBVALUEKIND_VARIANT:
if ( value.pvarValue ) { stm.PutByte(1); CStorageVariant * pVarnt = CastToStorageVariant( *value.pvarValue ); pVarnt->Marshall(stm); } else { stm.PutByte(0); } break;
case DBVALUEKIND_GUID:
if ( value.pGuid ) { stm.PutByte(1); stm.PutBlob( (BYTE *) value.pGuid, sizeof(GUID) ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_BYTES:
stm.PutByte(0); Win4Assert( !"NYI - DBVALUEKIND_BYTES" ); break;
case DBVALUEKIND_STR:
stm.PutByte(0); Win4Assert( !"NYI - DBVALUEKIND_STR" );
// if ( value.pzValue )
// {
// stm.PutByte(1);
// stm.PutString( value.pzValue );
// }
// else
// {
// stm.PutByte(0);
// }
break;
case DBVALUEKIND_NUMERIC:
if ( value.pdbnValue ) { stm.PutByte(1); CDbNumeric * pTemp = (CDbNumeric *) value.pdbnValue; pTemp->Marshall( stm ); } else { stm.PutByte(0); } break;
case DBVALUEKIND_BYREF:
stm.PutByte(0); Win4Assert( !"NYI - DBVALUEKIND_BYREF" ); break;
default:
Win4Assert( !"CDbCmdNode::Marshall - Invalid wKind" ); }
//
// If the child is non-null, serialize the child
//
if ( 0 != pctFirstChild ) { GetFirstChild()->Marshall(stm); }
//
// If the sibling is non-null, serialize the sibling
// If stack space on the client becomes an issue we could iterate to
// reduce stack depth.
//
if ( 0 != pctNextSibling ) { GetNextSibling()->Marshall(stm); }}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::UnMarshall, public
//
// Synopsis:
//
// Arguments: [stm] -
//
// Returns:
//
// History: 6-20-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
BOOL CDbCmdTreeNode::UnMarshall( PDeSerStream & stm ){ CleanupValue();
//
// De-Serialize the operator
//
op = (DBCOMMANDOP)stm.GetULong();
//
// Indicate the kind of the value.
//
Win4Assert( sizeof(wKind) == sizeof(USHORT) ); wKind = stm.GetUShort(); Win4Assert( !IsNotImplemented(wKind) );
hrError = stm.GetULong();
//
// Indicate if the child is null or not
//
BOOL fChildPresent = 0 != stm.GetByte(); BOOL fSiblingPresent = 0 != stm.GetByte();
//
// Next serialize the value.
//
WCHAR * pwszStr;
BOOL fSuccess = TRUE;
switch ( wKind ) { case DBVALUEKIND_EMPTY: break; // nothing to marshall
case DBVALUEKIND_BOOL: Win4Assert( sizeof(DBTYPE_BOOL) == sizeof(BYTE) ); case DBVALUEKIND_UI1: case DBVALUEKIND_I1: value.schValue = (BYTE) stm.GetByte(); break;
case DBVALUEKIND_UI2: case DBVALUEKIND_I2: value.usValue = stm.GetUShort(); break;
case DBVALUEKIND_I4: case DBVALUEKIND_UI4: value.ulValue = stm.GetULong(); break;
case DBVALUEKIND_R4: value.flValue = stm.GetFloat(); break;
case DBVALUEKIND_R8: value.dblValue = stm.GetDouble(); break;
case DBVALUEKIND_CY: case DBVALUEKIND_DATE: case DBVALUEKIND_ERROR: case DBVALUEKIND_I8: case DBVALUEKIND_UI8: stm.GetBlob( (BYTE *) &value, sizeof(value) ); break;
case DBVALUEKIND_WSTR: pwszStr = GetWString( stm, fSuccess); if ( fSuccess ) { value.pwszValue = pwszStr; } break;
case DBVALUEKIND_BSTR: pwszStr = GetWString( stm, fSuccess, TRUE ); if ( fSuccess ) { value.pwszValue = pwszStr; } break;
case DBVALUEKIND_COMMAND: case DBVALUEKIND_IDISPATCH: case DBVALUEKIND_MONIKER: case DBVALUEKIND_ROWSET: case DBVALUEKIND_IUNKNOWN: vqDebugOut(( DEB_WARN, "CDbCmdNode::UnMarshall -- Unmarshalling " "interface pointer failed\n" )); stm.GetByte(); wKind = DBVALUEKIND_EMPTY; break;
case DBVALUEKIND_BYGUID:
if ( 0 != stm.GetByte() ) { CDbByGuid * pTemp = new CDbByGuid(); if ( pTemp ) { value.pdbbygdValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_COLDESC:
Win4Assert(! "DBVALUEKIND_COLDESC unsupported !"); break;
case DBVALUEKIND_ID:
if ( 0 != stm.GetByte() ) { CDbColId * pTemp = new CDbColId(); if ( pTemp ) { value.pdbidValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENT:
if ( 0 != stm.GetByte() ) { CDbContent * pTemp = new CDbContent(); if ( pTemp ) { value.pdbcntntValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENTPROXIMITY:
if ( 0 != stm.GetByte() ) { CDbContentProximity * pTemp = new CDbContentProximity(); if ( pTemp ) { value.pdbcntntproxValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_CONTENTVECTOR:
if ( 0 != stm.GetByte() ) { CDbContentVector * pTemp = new CDbContentVector(); if ( pTemp ) { value.pdbcntntvcValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_LIKE:
if ( 0 != stm.GetByte() ) { CDbLike * pTemp = new CDbLike(); if ( pTemp ) { value.pdblikeValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_GROUPINFO:
if ( 0 != stm.GetByte() ) { CDbGroupInfo * pTemp = new CDbGroupInfo; if ( pTemp ) { value.pdbgrpinfValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_PARAMETER:
if ( 0 != stm.GetByte() ) { CDbParameter * pTemp = new CDbParameter(); if ( pTemp ) { value.pdbparamValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall(stm); } else { fSuccess = FALSE; } }
break;
case DBVALUEKIND_PROPERTY:
if ( 0 != stm.GetByte() ) { CDbPropSet * pTemp = new CDbPropSet(); if ( pTemp ) { value.pdbpropValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_SETFUNC:
stm.GetByte(); Win4Assert( !"NYI - DBVALUEKIND_SETFUNC" ); break;
case DBVALUEKIND_SORTINFO:
if ( 0 != stm.GetByte() ) { CDbSortInfo * pTemp = new CDbSortInfo(); if ( pTemp ) { value.pdbsrtinfValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } }
break;
case DBVALUEKIND_TEXT:
if ( stm.GetByte() ) { CDbText * pTemp = new CDbText(); if ( pTemp ) { value.pdbtxtValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall( stm ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_VARIANT:
if ( stm.GetByte() ) { CStorageVariant * pTemp = new CStorageVariant(stm); if ( pTemp ) { value.pvarValue = (VARIANT *) (void *) pTemp; } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_GUID:
if ( stm.GetByte() ) { value.pGuid = new GUID; if ( value.pGuid ) { stm.GetBlob( (BYTE *) value.pGuid, sizeof(GUID) ); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_BYTES:
stm.GetByte(); Win4Assert( !"NYI - DBVALUEKIND_BYTES" ); break;
case DBVALUEKIND_STR:
stm.GetByte(); Win4Assert( !"NYI - DBVALUEKIND_STR" ); break;
case DBVALUEKIND_NUMERIC:
if ( stm.GetByte() ) { CDbNumeric * pTemp = new CDbNumeric(); if ( pTemp ) { value.pdbnValue = pTemp->CastToStruct(); fSuccess = pTemp->UnMarshall(stm); } else { fSuccess = FALSE; } } break;
case DBVALUEKIND_BYREF:
stm.GetByte(); Win4Assert( !"NYI - DBVALUEKIND_BYREF" ); break;
default: Win4Assert( !"CDbCmdNode::UnMarshall - Invalid wKind" ); }
if ( !fSuccess ) { vqDebugOut(( DEB_WARN, "UnMarshalling 0x%X Failed for out of memory\n", this )); return FALSE; }
//
// If the child is non-null, serialize the child
//
if ( fChildPresent ) { pctFirstChild = new CDbCmdTreeNode(); if ( 0 != pctFirstChild ) fSuccess = GetFirstChild()->UnMarshall(stm); else fSuccess = FALSE; }
if ( !fSuccess ) { return FALSE; }
//
// If the sibling is non-null, serialize the sibling
//
if ( fSiblingPresent ) { pctNextSibling = new CDbCmdTreeNode(); if ( 0 != pctNextSibling ) { fSuccess = GetNextSibling()->UnMarshall(stm); } else { fSuccess = FALSE; } }
return fSuccess;}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::GetWeight, protected
//
// Synopsis:
//
// Arguments: [lWeight] - The weight to be set.
//
// Returns: The weight.
//
// History: 13-Aug-97 KrishnaN Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CDbCmdTreeNode::SetWeight( LONG lWeight ){ switch (GetValueType()) { // Takes care of DBOP_content and DBOP_content_freetext
case DBVALUEKIND_CONTENT: { CDbContentRestriction *pCont = (CDbContentRestriction *)this;
pCont->SetWeight( lWeight ); break; }
// Takes care of DBOP_vector_or
case DBVALUEKIND_CONTENTVECTOR: { CDbVectorRestriction *pVector = (CDbVectorRestriction *)this; pVector->SetWeight(lWeight); break; }
case DBVALUEKIND_LIKE: { Win4Assert(DBOP_like == GetCommandType()); CDbPropertyRestriction *pProp = (CDbPropertyRestriction *)this; pProp->SetWeight(lWeight); break; }
case DBVALUEKIND_CONTENTPROXIMITY: { Win4Assert(DBOP_content_proximity == GetCommandType()); CDbProximityNodeRestriction *pProx = (CDbProximityNodeRestriction *)this; pProx->SetWeight(lWeight); break; }
case DBVALUEKIND_I4: { switch (GetCommandType()) { case DBOP_equal: case DBOP_not_equal: case DBOP_less: case DBOP_less_equal: case DBOP_greater: case DBOP_greater_equal:
case DBOP_equal_any: case DBOP_not_equal_any: case DBOP_less_any: case DBOP_less_equal_any: case DBOP_greater_any: case DBOP_greater_equal_any:
case DBOP_equal_all: case DBOP_not_equal_all: case DBOP_less_all: case DBOP_less_equal_all: case DBOP_greater_all: case DBOP_greater_equal_all:
case DBOP_anybits: case DBOP_allbits: case DBOP_anybits_any: case DBOP_allbits_any: case DBOP_anybits_all: case DBOP_allbits_all: { CDbPropertyRestriction *pProp = (CDbPropertyRestriction *)this; pProp->SetWeight(lWeight); break; }
case DBOP_not: { CDbNotRestriction *pNot = (CDbNotRestriction *)this; pNot->SetWeight(lWeight); break; }
case DBOP_or: case DBOP_and: { CDbBooleanNodeRestriction *pBoolean = (CDbBooleanNodeRestriction *)this; pBoolean->SetWeight(lWeight); break; }
default: Win4Assert(!"How did we get here?"); break; } break; }
default: Win4Assert(!"How did we get here?"); break; }}
//+---------------------------------------------------------------------------
//
// Method: CDbCmdTreeNode::GetWeight, protected
//
// Synopsis:
//
// Returns: The weight.
//
// History: 13-Aug-97 KrishnaN Created
//
// Notes:
//
//----------------------------------------------------------------------------
LONG CDbCmdTreeNode::GetWeight() const{ switch (GetValueType()) { case DBVALUEKIND_CONTENT: { CDbContentRestriction *pCont = (CDbContentRestriction *)this; return pCont->GetWeight(); }
case DBVALUEKIND_CONTENTVECTOR: { CDbVectorRestriction *pVector = (CDbVectorRestriction *)this; return pVector->GetWeight(); }
case DBVALUEKIND_CONTENTPROXIMITY: { CDbProximityNodeRestriction *pProx = (CDbProximityNodeRestriction *)this; return pProx->GetWeight(); }
case DBVALUEKIND_LIKE: { CDbPropertyRestriction *pProp = (CDbPropertyRestriction *)this; return pProp->GetWeight(); }
case DBVALUEKIND_I4: { switch (GetCommandType()) { case DBOP_equal: case DBOP_not_equal: case DBOP_less: case DBOP_less_equal: case DBOP_greater: case DBOP_greater_equal:
case DBOP_equal_any: case DBOP_not_equal_any: case DBOP_less_any: case DBOP_less_equal_any: case DBOP_greater_any: case DBOP_greater_equal_any:
case DBOP_equal_all: case DBOP_not_equal_all: case DBOP_less_all: case DBOP_less_equal_all: case DBOP_greater_all: case DBOP_greater_equal_all:
case DBOP_anybits: case DBOP_allbits: case DBOP_anybits_any: case DBOP_allbits_any: case DBOP_anybits_all: case DBOP_allbits_all:
{ CDbPropertyRestriction *pProp = (CDbPropertyRestriction *)this; return pProp->GetWeight(); }
case DBOP_not: { CDbNotRestriction *pNot = (CDbNotRestriction *)this; return pNot->GetWeight(); }
case DBOP_or: case DBOP_and: { CDbBooleanNodeRestriction *pVector = (CDbBooleanNodeRestriction *)this; return pVector->GetWeight(); }
default: Win4Assert(!"How did we get here?"); break; } break; }
default: Win4Assert(!"Need to call the GetWeight for the appropriate class."); break; }
return MAX_QUERY_RANK;}
//+---------------------------------------------------------------------------
//
// Method: CDbColumnNode::CDbColumnNode, public
//
// Synopsis: Construct a CDbColumnNode
//
// Arguments: [guidPropSet] -
// [wcsProperty] -
//
// History: 6-06-95 srikants Created
//
// Notes: The assert here validates an assumption in the inline
// SetPropSet and GetPropSet methods.
//
//----------------------------------------------------------------------------
CDbColumnNode::CDbColumnNode( GUID const & guidPropSet, WCHAR const * wcsProperty ) : CDbCmdTreeNode(DBOP_column_name){ wKind = DBVALUEKIND_ID; CDbColId * pTemp = new CDbColId( guidPropSet, wcsProperty ); if ( 0 != pTemp && !pTemp->IsValid() ) { delete pTemp; pTemp = 0; }
value.pdbidValue = (DBID *) pTemp;}
//+---------------------------------------------------------------------------
//
// Method: CDbColumnNode::CDbColumnNode, public
//
// Synopsis: Construct a CDbColumnNode from a DBID
//
// Arguments: [rColSpec] - DBID from which to initialize the node
//
// History: 6-20-95 srikants Created
//
// Notes: The column must be named by guid & number, or guid & name.
//
//----------------------------------------------------------------------------
CDbColumnNode::CDbColumnNode( DBID const & propSpec, BOOL fIMeanIt ) : CDbCmdTreeNode(DBOP_column_name){
wKind = DBVALUEKIND_ID; CDbColId * pTemp = new CDbColId( propSpec ); if ( 0 != pTemp && !pTemp->IsValid() ) { delete pTemp; pTemp = 0; }
value.pdbidValue = (DBID *) pTemp;}
//+---------------------------------------------------------------------------
//
// Member: CDbScalarValue::Value
//
// Synopsis: Gets the value in the scalar into a variant.
//
// Arguments: [valOut] - Output value.
//
// Returns: TRUE if successful. FALSE o/w
//
// History: 11-16-95 srikants Created
//
//----------------------------------------------------------------------------
void CDbScalarValue::Value( CStorageVariant & valOut ){ //
// Deallocate any memory allocated for this node.
//
switch ( wKind ) { case DBVALUEKIND_EMPTY: valOut.SetEMPTY(); break;
case DBVALUEKIND_BOOL: valOut.SetBOOL((SHORT)value.fValue); break;
case DBVALUEKIND_UI1: valOut.SetUI1( value.uchValue ); break;
case DBVALUEKIND_I1: valOut.SetI1( value.schValue ); break;
case DBVALUEKIND_UI2: valOut = value.usValue; break;
case DBVALUEKIND_I2: valOut = value.sValue; break;
case DBVALUEKIND_I4: valOut = value.lValue; break;
case DBVALUEKIND_UI4: valOut = value.ulValue; break;
case DBVALUEKIND_R4: valOut = value.flValue; break;
case DBVALUEKIND_R8: valOut = value.dblValue; break;
case DBVALUEKIND_CY: valOut = value.cyValue; break;
case DBVALUEKIND_DATE: valOut = value.dateValue; break;
case DBVALUEKIND_ERROR: valOut = value.scodeValue; break;
case DBVALUEKIND_I8: valOut.SetI8( *((LARGE_INTEGER *)(&value.llValue)) ); break;
case DBVALUEKIND_UI8: valOut.SetUI8( *((ULARGE_INTEGER *)(&value.ullValue)) ); break;
case DBVALUEKIND_WSTR: valOut = value.pwszValue; break;
case DBVALUEKIND_BSTR: valOut.SetBSTR( (BSTR)value.pbstrValue ); break;
case DBVALUEKIND_VARIANT:
{ CStorageVariant * pVarnt = _GetStorageVariant(); if ( 0 != pVarnt ) { valOut = *pVarnt; } else { valOut.SetEMPTY(); } }
break;
case DBVALUEKIND_STR:
if ( value.pzValue ) { valOut = value.pzValue; } else { valOut.SetEMPTY(); } break;
case DBVALUEKIND_BYTES: case DBVALUEKIND_NUMERIC: case DBVALUEKIND_BYREF: valOut.SetEMPTY(); Win4Assert( !"CDbScalarValue::Value - Not Implemented" ); break;
default: valOut.SetEMPTY(); Win4Assert( !"Illegal Case Statement" );
}}
|
