diff options
Diffstat (limited to '')
| -rw-r--r-- | public/sdk/inc/dbcmdtre.hxx | 3771 |
1 files changed, 3771 insertions, 0 deletions
diff --git a/public/sdk/inc/dbcmdtre.hxx b/public/sdk/inc/dbcmdtre.hxx new file mode 100644 index 000000000..1d88a32dd --- /dev/null +++ b/public/sdk/inc/dbcmdtre.hxx @@ -0,0 +1,3771 @@ +//+--------------------------------------------------------------------------- +// +// Microsoft Windows +// Copyright (C) Microsoft Corporation, 1992 - 1994. +// +// File: dbcmdbas.hxx +// +// Contents: Helper classes for dealing with DBCOMMANDTREE and DBID +// structures. +// +// Classes: CDbCmdTreeNode +// CDbColumnNode +// CDbScalarValue +// CDbTableId +// CDbSelectNode +// CDbListAnchor +// CDbProjectListAnchor +// CDbProjectNode +// CDbSortListAnchor +// CDbSortListElement +// CDbSortNode +// CDbRestriction +// CDbNodeRestriction +// CDbNotRestriction +// CDbPropBaseRestriction +// CDbPropertyRestriction +// CDbVectorRestriction +// CDbContentBaseRestriction +// CDbNatLangRestriction +// CDbContentRestriction +// CDbTopNode +// CDbColId +// CDbDataType +// CDbColDef +// CDbGuidName +// CDbGuidPropid +// CDbText +// CDbContent +// CDbSortInfo +// CDbGroupInfo +// CDbColumns +// CDbSortSet +// +// Functions: CastToStorageVariant +// +// History: 6-06-95 srikants Created +// +//---------------------------------------------------------------------------- + + +#ifndef __DBCMDTRE_HXX__ +#define __DBCMDTRE_HXX__ + +#include <oledb.h> +#include <sstream.hxx> +#include <stgvar.hxx> + + + +//+--------------------------------------------------------------------------- +// +// Function: CastToStorageVariant +// +// Synopsis: To treat a variant as a CStorageVariant. Because CStorageVariant +// derives from PROPVARIANT in a "protected" fashion, we cannot +// directly typecast a PROPVARIANT * to a CStorageVariant * +// +// Arguments: [varnt] - The variant that must be type casted. +// +// Returns: A pointer to varnt as a CStorageVariant. +// +// History: 6-06-95 srikants Created +// +// Notes: There are two overloaded implementations, one to convert +// a reference to const to a pointer to const. +// +//---------------------------------------------------------------------------- + +inline +CStorageVariant * CastToStorageVariant( VARIANT & varnt ) +{ + return (CStorageVariant *) ((void *) &varnt); +} + +inline +CStorageVariant const * CastToStorageVariant( VARIANT const & varnt ) +{ + return (CStorageVariant *) ((void *) &varnt); +} + +//+--------------------------------------------------------------------------- +// +// Class: CDbColId +// +// Purpose: Wrapper for DBID +// +// Interface: Marshall -- +// UnMarshall -- +// Get -- +// +// History: 6-21-95 srikants Created +// +// Notes: This class does not completely handle the simple name +// and pointer to guid forms of DBID. +// +//---------------------------------------------------------------------------- + +class CDbColId : public DBID +{ + +public: + + CDbColId(); + + CDbColId( GUID const & guidPropSet, PROPID pidProperty ) + { + eKind = DBKIND_GUID_PROPID; + guid = guidPropSet; + ulPropid = pidProperty; + } + + CDbColId( GUID const & guidPropSet, WCHAR const * wcsProperty ); + + CDbColId( DBID const & propSpec ); + + CDbColId( CDbColId const & propSpec ); + + CDbColId( PROPID pidProperty ) + { + eKind = DBKIND_PROPID; + ulPropid = pidProperty; + } + + CDbColId( WCHAR const * wcsProperty ) + { + eKind = DBKIND_NAME; + pwszName = 0; + + SetProperty( wcsProperty ); + } + + ~CDbColId() + { + Cleanup(); + } + + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + DBID & Get() const { return (DBID &)*this; } + + BOOL Copy( DBID const & rhs ); + + CDbColId & operator=( CDbColId const & Property ); + + // + // Comparators + // + int operator==( CDbColId const & prop ) const; + int operator!=( CDbColId const & prop ) const + { + return !operator==(prop); + } + + // + // Member variable access + // + void SetPropSet( GUID const & guidPropSet ) + { + if ( !_IsPGuidUsed() ) + { + guid = guidPropSet; + if ( DBKIND_PROPID == eKind ) + { + eKind = DBKIND_GUID_PROPID; + } + else if ( DBKIND_NAME == eKind ) + { + eKind = DBKIND_GUID_NAME; + } + } + else + *pguid = guidPropSet; + + } + + GUID const & GetPropSet() const + { + if ( !_IsPGuidUsed() ) + return guid; + else + return *pguid; + } + + void SetProperty( PROPID pidProperty ) + { + Cleanup(); + eKind = DBKIND_GUID_PROPID; + ulPropid = pidProperty; + } + + BOOL SetProperty( WCHAR const * wcsProperty ); + + WCHAR const * GetPropertyName() const + { +// Win4Assert( IsPropertyName() ); + return pwszName; + } + + WCHAR * GetPropertyName() + { +// Win4Assert( IsPropertyName() ); + return pwszName; + } + + PROPID GetPropertyPropid() const + { +// Win4Assert( IsPropertyPropid() ); + return ulPropid; + } + + PROPSPEC GetPropSpec() const + { + return( *(PROPSPEC *)(void *)&eKind ); + } + + + BOOL IsPropertyName() const + { + return DBKIND_GUID_NAME == eKind || + DBKIND_PGUID_NAME == eKind || + DBKIND_NAME == eKind; + } + + BOOL IsPropertyPropid() const + { + return DBKIND_PROPID == eKind || + DBKIND_GUID_PROPID == eKind || + DBKIND_PGUID_PROPID == eKind; + } + + BOOL IsPropSetPresent() const + { + return (DBKIND_PROPID != eKind) && (DBKIND_NAME != eKind); + } + + BOOL IsValid() const + { + if ( !_IsValidKind() ) + return FALSE; + + if ( DBKIND_GUID_PROPID == eKind || DBKIND_PROPID == eKind || + DBKIND_GUID == eKind ) + { + return TRUE; + } + else if ( DBKIND_GUID_NAME == eKind || DBKIND_NAME == eKind ) + { + return 0 != pwszName; + } + else if ( DBKIND_PGUID_PROPID == eKind ) + { + return 0 != pguid; + } + else + { +// Win4Assert( DBKIND_PGUID_NAME == eKind ); + return 0 != pguid && 0 != pwszName; + } + } + + DBID * CastToStruct() + { + return (DBID *) this; + } + + DBID const * CastToStruct() const + { + return (DBID const *) this; + } + + void Cleanup(); + + // + // Memory allocation + // + void * operator new( size_t size ); + inline void * operator new( size_t size, void * p ); + void operator delete( void * p ); + + +private: + + BOOL _IsPGuidUsed() const + { + return DBKIND_PGUID_NAME == eKind || DBKIND_PGUID_PROPID == eKind; + } + + BOOL _IsValidKind() const + { + return eKind >= DBKIND_GUID_NAME && eKind <= DBKIND_GUID; + } +}; + + +//+--------------------------------------------------------------------------- +// +// Method: CDbColId::operator new +// +// Synopsis: Command tree node allocation via IMalloc::Alloc +// +// Arguments: [size] - +// +// History: 6-06-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline void * CDbColId::operator new( size_t size ) +{ + void * p = CoTaskMemAlloc( size ); + + return( p ); +} + +//+--------------------------------------------------------------------------- +// +// Method: CDbColId::operator new +// +// Synopsis: null allocator +// +// Arguments: [size] - +// [p] - +// +// History: 6-06-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline void * CDbColId::operator new( size_t size, void * p ) +{ + return( p ); +} + +//+--------------------------------------------------------------------------- +// +// Method: CDbColId::operator delete +// +// Synopsis: CDbColId deallocation via IMalloc::Free +// +// Arguments: [p] - +// +// History: 6-06-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline void CDbColId::operator delete( void * p ) +{ + if ( p ) + CoTaskMemFree( p ); +} + + + +#if 0 + +class CXXXX : public XXXX +{ + +public: + + ~CXXX(); + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + BOOL IsValid() const + { + return TRUE; + } + +private: + +}; + +#endif // 0 + + +//+--------------------------------------------------------------------------- +// +// Class: CDbCmdTreeNode +// +// Purpose: Basic DBCOMMANDTREE node +// +// History: 6-06-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbCmdTreeNode : protected DBCOMMANDTREE +{ + + // BUGBUG - needed to access AppendChild. Consider having a base class + // for projectlist element nodes + friend class CDbListAnchor; + +public: + + // + // Constructor and Destructor + // + CDbCmdTreeNode( DBCOMMANDOP opVal = DBOP_DEFAULT, + WORD eType = DBVALUEKIND_EMPTY ) + { + RtlZeroMemory( this, sizeof(CDbCmdTreeNode) ); + op = opVal; + wKind = eType; +// +// pctFirstChild = pctNextSibling = 0; +// This assignment is not needed because we have already initialized +// the whole structure with 0s. +// + } + + ~CDbCmdTreeNode(); + + DBCOMMANDOP GetCommandType() const { return op; } + + DBVALUEKIND GetValueType() const { return wKind; } + + CDbCmdTreeNode * GetFirstChild() const + { + return (CDbCmdTreeNode *) pctFirstChild; + } + + CDbCmdTreeNode * GetNextSibling() const + { + return (CDbCmdTreeNode *) pctNextSibling; + } + + // BUGBUG - we should collapse these two calls into one + void SetOperatorError( SCODE scErr ) + { + hrError = scErr; + } + + void SetContextError( SCODE scErr ) + { + hrError = scErr; + } + + SCODE GetOperatorError( ) const { return hrError; } + + SCODE GetContextError( ) const { return hrError; } + + void FreeChildren() + { + if ( 0 != pctFirstChild ) + { + delete pctFirstChild; + pctFirstChild = 0; + } + } + + DBCOMMANDTREE * CastToStruct() const + { + return (DBCOMMANDTREE *)this; + } + + static CDbCmdTreeNode * CastFromStruct( DBCOMMANDTREE * pNode ) + { + return (CDbCmdTreeNode *) (pNode); + } + + static CDbCmdTreeNode const * CastFromStruct( DBCOMMANDTREE const * pNode ) + { + return (CDbCmdTreeNode const *) (pNode); + } + + BOOL IsScalarNode() const + { + return DBOP_scalar_constant == op; + } + + BOOL IsColumnName() const + { + return DBOP_column_name == op; + } + + BOOL IsOpValid( DBCOMMANDOP opVal ) const + { + return op == opVal; + } + + BOOL IsSelectNode() const + { + return DBOP_select == op; + } + + BOOL IsProjectNode() const + { + return DBOP_project == op; + } + + BOOL IsListAnchor() const + { + return DBOP_project_list_anchor == op || + DBOP_sort_list_anchor == op; + } + + // + // Cloning the tree + // + CDbCmdTreeNode * Clone( BOOL fCopyErrors = FALSE ) const; + + void CDbCmdTreeNode::TransferNode( CDbCmdTreeNode *pNode ); + + // + // Serialization and DeSerialization + // + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + static CDbCmdTreeNode * UnMarshallTree( PDeSerStream & stm ); + + static void PutWString( PSerStream & stm, const WCHAR * pwszStr ); + static WCHAR * GetWString( PDeSerStream & stm, BOOL & fSuccess ); + static WCHAR * AllocAndCopyWString( const WCHAR * pSrc ); + + // + // Memory allocation + // + void * operator new( size_t size ); + inline void * operator new( size_t size, void * p ); + void operator delete( void * p ); + + // + // A NULL guid variable. + // + static const GUID guidNull; // NULL guid + +protected: + + void CleanupDataValue(); + + void CleanupValue() + { + if ( DBVALUEKIND_EMPTY != wKind ) + CleanupDataValue(); + } + + // + // Setting protected members + // + + void SetCommandType( DBCOMMANDOP opVal ) + { + op = opVal; + } + + void SetValueType( WORD wKindVal ) + { + wKind = wKindVal; + } + + // + // Manipulating the tree. + // + void AppendChild( CDbCmdTreeNode *pChild ); + void InsertChild( CDbCmdTreeNode *pChild ); + + void AppendSibling( CDbCmdTreeNode *pSibling ); + void InsertSibling( CDbCmdTreeNode *pSibling ) + { +// Win4Assert( 0 == pSibling->pctNextSibling ); + pSibling->pctNextSibling = pctNextSibling; + pctNextSibling = pSibling; + } + + CDbCmdTreeNode * RemoveFirstChild( ); + +private: + + // + // To accidentally prevent someone from creating copy constructors + // + CDbCmdTreeNode( const CDbCmdTreeNode & rhs ); + CDbCmdTreeNode & operator=( const CDbCmdTreeNode & rhs ); + + static unsigned SizeInBytes( const WCHAR * pwszStr ) + { + if ( 0 != pwszStr ) + { + return (wcslen( pwszStr )+1)*sizeof(WCHAR); + } + else + { + return 0; + } + } + +}; + +//+--------------------------------------------------------------------------- +// +// Method: CDbCmdTreeNode::operator new +// +// Synopsis: Command tree node allocation via IMalloc::Alloc +// +// Arguments: [size] - +// +// History: 6-06-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline void * CDbCmdTreeNode::operator new( size_t size ) +{ + void * p = CoTaskMemAlloc( size ); + + return( p ); +} + +//+--------------------------------------------------------------------------- +// +// Method: CDbCmdTreeNode::operator new +// +// Synopsis: null allocator +// +// Arguments: [size] - +// [p] - +// +// History: 6-06-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline void * CDbCmdTreeNode::operator new( size_t size, void * p ) +{ + return( p ); +} + +//+--------------------------------------------------------------------------- +// +// Method: CDbCmdTreeNode::operator delete +// +// Synopsis: Command tree node deallocation via IMalloc::Free +// +// Arguments: [p] - +// +// History: 6-06-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline void CDbCmdTreeNode::operator delete( void * p ) +{ + if ( p ) + CoTaskMemFree( p ); +} + + +//+--------------------------------------------------------------------------- +// +// Class: CDbByGuid () +// +// Purpose: +// +// History: 11-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbByGuid : public DBBYGUID +{ + +public: + + CDbByGuid() + { + RtlZeroMemory( this, sizeof(DBBYGUID) ); + } + + CDbByGuid( GUID const & guidIn, ULONG cbInfoIn = 0, const BYTE * pbInfoIn = 0 ) + { + guid = guidIn; + cbInfo = cbInfoIn; + + if ( 0 != pbInfoIn && 0 != cbInfoIn ) + { + pbInfo = (BYTE *) CoTaskMemAlloc( cbInfoIn ); + if ( 0 != pbInfo ) + { + RtlCopyMemory( pbInfo, pbInfoIn, cbInfoIn ); + } + } + else + { + pbInfo = 0; + } + } + + CDbByGuid( DBBYGUID const & rhs ) + { + cbInfo = 0; + pbInfo = 0; + + CDbByGuid const * pRhs = (CDbByGuid *) &rhs; + operator=( *pRhs ); + } + + ~CDbByGuid() + { + _Cleanup(); + } + + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + CDbByGuid & operator=( CDbByGuid const & rhs ); + + // + // Comparators + // + int operator==( CDbByGuid const & rhs ) const; + int operator!=( CDbByGuid const & rhs ) const + { + return !operator==(rhs); + } + + // + // Member variable access + // + void SetPropSet( GUID const & guidIn ) + { + guid = guidIn; + } + + GUID const & GetGuid() const + { + return guid; + } + + BOOL IsValid() const + { + return 0 != cbInfo ? 0 != pbInfo : TRUE; + } + + + DBBYGUID * CastToStruct() + { + return (DBBYGUID *) this; + } + + DBBYGUID const * CastToStruct() const + { + return (DBBYGUID const *) this; + } + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + +private: + + void _Cleanup() + { + if ( 0 != pbInfo ) + { + CoTaskMemFree( pbInfo ); + pbInfo = 0; + } + } + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbParameter +// +// Purpose: +// +// History: 11-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbParameter : public DBPARAMETER +{ + +public: + + CDbParameter() + { + RtlZeroMemory( this, sizeof(DBPARAMETER) ); + } + + CDbParameter( const DBPARAMETER & rhs ) + { + RtlZeroMemory( this, sizeof(DBPARAMETER) ); + Copy( rhs ); + } + + ~CDbParameter() + { + _Cleanup(); + } + + BOOL Copy( const DBPARAMETER & rhs ); + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + BOOL IsValid() const + { + return TRUE; + } + + DBPARAMETER * CastToStruct() + { + return (DBPARAMETER *) this; + } + + DBPARAMETER const * CastToStruct() const + { + return (DBPARAMETER const *) this; + } + +private: + + void _Cleanup(); + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbProperty +// +// Purpose: +// +// History: 11-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbProperty : public DBPROPERTY +{ + +public: + + CDbProperty() + { + RtlZeroMemory( this, sizeof(DBPROPERTY) ); + } + + CDbProperty( const DBPROPERTY & rhs ) + { + RtlZeroMemory( this, sizeof(DBPROPERTY) ); + Copy( rhs ); + } + + BOOL Copy( const DBPROPERTY & rhs ); + + ~CDbProperty(); + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + BOOL IsValid() const + { + return TRUE; + } + + DBPROPERTY * CastToStruct() + { + return (DBPROPERTY *) this; + } + + DBPROPERTY const * CastToStruct() const + { + return (DBPROPERTY const *) this; + } + +private: + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbContentVector +// +// Purpose: +// +// History: 11-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbContentVector : public DBCONTENTVECTOR +{ + +public: + + CDbContentVector( const CDbContentVector & rhs ) + { + cWeights = 0; + prgulWeights = 0; + Copy( *(rhs.CastToStruct()) ); + } + + CDbContentVector( const DBCONTENTVECTOR & rhs ) + { + cWeights = 0; + prgulWeights = 0; + Copy( rhs ); + } + + CDbContentVector( DWORD rank = 0 ) + { + dwRankingMethod = rank; + cWeights = 0; + prgulWeights = 0; + } + + ~CDbContentVector() + { + if ( 0 != prgulWeights ) + { + CoTaskMemFree( prgulWeights ); + prgulWeights = 0; + } + } + + void SetRankMethod( DWORD rank ) + { + dwRankingMethod = rank; + } + + ULONG GetWeightCount() + { + return cWeights; + } + + ULONG const * GetWeights() + { + return prgulWeights; + } + + void SetWeights( ULONG c, ULONG const *pul ) + { + if ( 0 != prgulWeights ) + CoTaskMemFree( prgulWeights ); + + prgulWeights = 0; + cWeights = c; + + if ( 0 != cWeights ) + { + unsigned cb = cWeights * sizeof ULONG; + + prgulWeights = (ULONG *) CoTaskMemAlloc( cb ); + + if ( 0 != prgulWeights ) + memcpy( prgulWeights, pul, cb ); + } + } + + ULONG RankMethod() const + { + return (ULONG) dwRankingMethod; + } + + DBCONTENTVECTOR * CastToStruct() + { + return (DBCONTENTVECTOR *) this; + } + + DBCONTENTVECTOR const * CastToStruct() const + { + return (DBCONTENTVECTOR const *) this; + } + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + BOOL IsValid() const + { + return ( ( 0 == cWeights ) || + ( 0 != prgulWeights ) ); + } + + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + +private: + + BOOL Copy( DBCONTENTVECTOR const & rhs ) + { + dwRankingMethod = rhs.dwRankingMethod; + cWeights = rhs.cWeights; + + SetWeights( rhs.cWeights, rhs.prgulWeights ); + + return TRUE; + } +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbNumeric +// +// Purpose: +// +// History: 11-16-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbNumeric : public DBNUMERIC +{ + +public: + + CDbNumeric() + { + RtlZeroMemory( this, sizeof(DBNUMERIC) ); + } + + CDbNumeric( const DBNUMERIC & rhs ) + { + RtlCopyMemory( this, &rhs, sizeof(DBNUMERIC) ); + } + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + BOOL IsValid() const + { + return TRUE; + } + + // + // Serialization and DeSerialization. + // + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + DBNUMERIC * CastToStruct() + { + return (DBNUMERIC *) this; + } + + DBNUMERIC const * CastToStruct() const + { + return (DBNUMERIC const *) this; + } + +private: + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbDataType +// +// Purpose: +// +// History: 6-21-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbDataType : public DBDATATYPE +{ + +public: + + CDbDataType( DBDATATYPE & dataType ) : DBDATATYPE(dataType) + { + + } + + CDbDataType() + { + RtlZeroMemory(this,sizeof(CDbDataType) ); + } + + void Marshall( PSerStream & stm ) const; + BOOL UnMarshall( PDeSerStream & stm ); + + void Cleanup(); + + DBDATATYPE & Get() const { return (DBDATATYPE &)*this; } + + BOOL Copy( DBDATATYPE const & rhs ); + + CDbDataType & operator=( CDbDataType & rhs ); + + DBDATATYPE * CastToStruct() + { + return (DBDATATYPE *) this; + } + + DBDATATYPE const * CastToStruct() const + { + return (DBDATATYPE const *) this; + } + +private: + +}; + + +//+--------------------------------------------------------------------------- +// +// Method: CDbDataType::Marshall +// +// Synopsis: +// +// Arguments: [stm] - +// +// Returns: +// +// Modifies: +// +// History: 6-21-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline +void CDbDataType::Marshall( PSerStream & stm ) const +{ + // + // Serialize the "wKind" field first. + // + stm.PutULong( eKind ); + + switch ( eKind ) + { + case DBDATATYPEKIND_BASETYPE: + + stm.PutULong( DBBASETYPE.edbdt ); + stm.PutULong( DBBASETYPE.cbMaxLength ); + stm.PutULong( DBBASETYPE.cbPrecision ); + stm.PutULong( DBBASETYPE.cbScale ); + + break; + + case DBDATATYPEKIND_DOMAIN: + + CDbCmdTreeNode::PutWString( stm, pwszDomainName ); + break; + + // default: + // Win4Assert( !"Illegal Case Statement" ); + } +} + +//+--------------------------------------------------------------------------- +// +// Method: CDbDataType::UnMarshall +// +// Synopsis: +// +// Arguments: [stm] - +// +// Returns: +// +// Modifies: +// +// History: 6-21-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline +BOOL CDbDataType::UnMarshall( PDeSerStream & stm ) +{ + BOOL fSuccess = TRUE; + + eKind = stm.GetULong(); + + switch ( eKind ) + { + case DBDATATYPEKIND_BASETYPE: + + DBBASETYPE.edbdt = stm.GetULong(); + DBBASETYPE.cbMaxLength = stm.GetULong(); + DBBASETYPE.cbPrecision = stm.GetULong(); + DBBASETYPE.cbScale = stm.GetULong(); + + break; + + case DBDATATYPEKIND_DOMAIN: + + pwszDomainName = + CDbCmdTreeNode::GetWString( stm, fSuccess ); + break; + + //default: + // vqDebugOut(( DEB_ERROR, "Illegal DBDATATYPEKIND 0x%X\n", + // wKind )); + } + + return fSuccess; +} + +//+--------------------------------------------------------------------------- +// +// Method: CDbDataType::Cleanup +// +// Synopsis: +// +// Returns: +// +// Modifies: +// +// History: 6-21-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +inline +void CDbDataType::Cleanup() +{ + if ( DBDATATYPEKIND_DOMAIN == eKind && + 0 != pwszDomainName ) + { + CoTaskMemFree( pwszDomainName ); + pwszDomainName = 0; + } +} + +//+--------------------------------------------------------------------------- +// +// Class: CDbColDef +// +// Purpose: +// +// History: 6-21-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbColDef // : protected DBCOLDEF +{ + +public: + + CDbColDef( DBCOLDEF & colDef ) : + _dbColId( colDef.dbcid ), + _dbDataType( colDef.dbdt ) + { + + } + + CDbColDef() : _dbColId(), _dbDataType() + { + + } + + void Cleanup() + { + _dbColId.Cleanup(); + _dbDataType.Cleanup(); + } + + void Marshall( PSerStream & stm ) const + { + _dbColId.Marshall( stm ); + _dbDataType.Marshall( stm ); + } + + BOOL UnMarshall( PDeSerStream & stm ) + { + BOOL fSuccess = _dbColId.UnMarshall( stm ); + if ( fSuccess ) + { + fSuccess = _dbDataType.UnMarshall( stm ); + } + + return fSuccess; + } + + BOOL Copy( CDbColDef const & rhs ) + { + BOOL fSuccess = _dbColId.Copy( rhs._dbColId.Get() ); + if ( fSuccess ) + { + fSuccess = _dbDataType.Copy( rhs._dbDataType.Get() ); + } + + return fSuccess; + } + + DBCOLDEF * CastToStruct() const + { + return (DBCOLDEF *) this; + } + +private: + + CDbColDef & operator=( CDbColDef & rhs ); + + CDbColId _dbColId; + CDbDataType _dbDataType; + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbText +// +// Purpose: Wrapper class for DBTEXT +// +// History: 6-22-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbText : public DBTEXT +{ +public: + + CDbText( DBTEXT const & text ) + { + Copy( text ); + } + + CDbText() + { + RtlZeroMemory( this,sizeof(CDbText) ); + } + + DBTEXT & GetText() const { return (DBTEXT &)*this; } + + BOOL Copy( const DBTEXT & rhs ) + { + BOOL fSuccess = TRUE; + RtlCopyMemory( this, &rhs, sizeof(DBTEXT) ); + pwszText = 0; + if ( 0 != rhs.pwszText ) + { + pwszText = + CDbCmdTreeNode::AllocAndCopyWString( rhs.pwszText ); + fSuccess = 0 != pwszText; + } + + return fSuccess; + } + + void Marshall( PSerStream & stm ) const + { + stm.PutGUID( guidDialect ); + CDbCmdTreeNode::PutWString( stm, pwszText ); + stm.PutULong( ulErrorLocator ); + stm.PutULong( ulTokenLength ); + } + + BOOL UnMarshall( PDeSerStream & stm ) + { + BOOL fSuccess; + stm.GetGUID( guidDialect ); + pwszText = CDbCmdTreeNode::GetWString( stm, fSuccess ); + if( fSuccess ) + { + ulErrorLocator = stm.GetULong(); + ulTokenLength = stm.GetULong(); + } + + return fSuccess; + } + + DBTEXT * CastToStruct() + { + return (DBTEXT *) this; + } + + DBTEXT const * CastToStruct() const + { + return (DBTEXT const *) this; + } + + +private: + + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbContent +// +// Purpose: Wrapper for DBCONTENT +// +// History: 6-22-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbContent : public DBCONTENT +{ + +public: + + CDbContent( DWORD fuzzyLevel, ULONG ulWeightIn, + LCID lcidIn, const WCHAR * pwszPhraseIn ) + { + dwFuzzyLevel = fuzzyLevel; + ulWeight = ulWeightIn; + lcid = lcidIn; + pwszPhrase = 0; + SetPhrase( pwszPhraseIn ); + } + + CDbContent() + { + RtlZeroMemory( this, sizeof(CDbContent) ); + } + + DBCONTENT & GetDbContent() const { return (DBCONTENT &)*this; } + + BOOL Copy( DBCONTENT const & rhs ) + { + BOOL fSuccess = TRUE; + RtlCopyMemory( this, &rhs, sizeof(DBCONTENT) ); + pwszPhrase = 0; + if ( 0 != rhs.pwszPhrase ) + { + pwszPhrase = + CDbCmdTreeNode::AllocAndCopyWString( rhs.pwszPhrase ); + fSuccess = 0 != pwszPhrase; + } + + return fSuccess; + } + + CDbContent ( DBCONTENT const & content ) + { + Copy( content ); + } + + ~CDbContent() + { + if ( 0 != pwszPhrase ) + { + CoTaskMemFree( pwszPhrase ); + } + } + + void Marshall( PSerStream & stm ) const + { + stm.PutULong( dwFuzzyLevel ); + stm.PutULong( ulWeight ); + stm.PutULong( lcid ); + CDbCmdTreeNode::PutWString( stm, pwszPhrase ); + } + + BOOL UnMarshall( PDeSerStream & stm ) + { + BOOL fSuccess = TRUE; + + dwFuzzyLevel = stm.GetULong(); + ulWeight = stm.GetULong( ); + lcid = stm.GetULong(); + pwszPhrase = CDbCmdTreeNode::GetWString( stm, fSuccess ); + + return fSuccess; + } + + // + // Data member access and set methods. + // + WCHAR const * GetPhrase() const + { + return pwszPhrase; + } + + BOOL SetPhrase( const WCHAR * pwszPhraseIn ) + { + if ( 0 != pwszPhrase ) + { + CoTaskMemFree( pwszPhrase ); + } + + pwszPhrase = CDbCmdTreeNode::AllocAndCopyWString( pwszPhraseIn ); + return 0 != pwszPhrase; + } + + LCID GetLocale() const { return lcid; } + void SetLocale( LCID lcidIn ) { lcid = lcidIn; } + + ULONG GetWeight() const { return ulWeight; } + void SetWeight( ULONG weight ) { ulWeight = weight; } + + DWORD GetFuzzyLevel() const { return dwFuzzyLevel; } + void SetFuzzyLevel( DWORD fuzzyLevel ) { dwFuzzyLevel = fuzzyLevel; } + + void Cleanup() + { + if ( 0 != pwszPhrase ) + { + CoTaskMemFree( pwszPhrase ); + pwszPhrase = 0; + } + } + + DBCONTENT * CastToStruct() + { + return (DBCONTENT *) this; + } + + DBCONTENT const * CastToStruct() const + { + return (DBCONTENT const *) this; + } + + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + BOOL IsValid() const + { + return 0 != pwszPhrase; + } + +private: + + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbSortInfo +// +// Purpose: WRAPPER for DBSORTINFO +// +// History: 6-22-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbSortInfo : public DBSORTINFO +{ +public: + + CDbSortInfo( BOOL fDescending = FALSE, LCID lcidIn = 0 ) + { + fDesc = fDescending; + lcid = lcidIn; + } + + CDbSortInfo( DBSORTINFO & sortInfo ) : DBSORTINFO(sortInfo) {} + + BOOL Copy( DBSORTINFO const & rhs ) + { + *(DBSORTINFO *)this = rhs; + return TRUE; + } + + void Marshall( PSerStream & stm ) const + { + stm.PutULong( lcid ); + stm.PutULong( fDesc ); + } + + BOOL UnMarshall( PDeSerStream & stm ) + { + lcid = stm.GetULong(); + fDesc = stm.GetULong(); + + return TRUE; + } + + DBSORTINFO & Get() const { return (DBSORTINFO &)*this; } + + LCID GetLocale() const { return lcid; } + BOOL GetDirection() const { return fDesc; } + + void SetLocale(LCID lcidIn) { lcid = lcidIn; } + void SetDirection(BOOL fDescIn) { fDesc = fDescIn; } + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + BOOL IsValid() const + { + return TRUE; + } + + DBSORTINFO * CastToStruct() + { + return (DBSORTINFO *) this; + } + + DBSORTINFO const * CastToStruct() const + { + return (DBSORTINFO const *) this; + } + +private: + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbGroupInfo +// +// Purpose: WRAPPER for DBGROUPINFO +// +// History: 6-22-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbGroupInfo : public DBGROUPINFO +{ + +public: + + CDbGroupInfo( DBGROUPINFO & groupInfo ) : DBGROUPINFO(groupInfo) {} + CDbGroupInfo() + { + RtlZeroMemory( this, sizeof(CDbGroupInfo) ); + } + + DBGROUPINFO & Get() const { return *(DBGROUPINFO *)this; } + + BOOL Copy( DBGROUPINFO const & rhs ) + { + *(DBGROUPINFO *)this = rhs; + return TRUE; + } + + void Marshall( PSerStream & stm ) const + { + stm.PutULong( lcid ); + } + + BOOL UnMarshall( PDeSerStream & stm ) + { + lcid = stm.GetULong(); + return TRUE; + } + + DBGROUPINFO * CastToStruct() + { + return (DBGROUPINFO *) this; + } + + DBGROUPINFO const * CastToStruct() const + { + return (DBGROUPINFO const *) this; + } + + + // + // Memory allocation + // + void * operator new( size_t size ) + { + void * p = CoTaskMemAlloc( size ); + return( p ); + } + + inline void * operator new( size_t size, void * p ) + { + return( p ); + } + + void operator delete( void * p ) + { + if ( p ) + CoTaskMemFree( p ); + } + + BOOL IsValid() const + { + return TRUE; + } + +private: + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbColumnNode +// +// Purpose: A DBCOMMANDTREE node representing a column +// +// History: 6-07-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbColumnNode : public CDbCmdTreeNode +{ + +public: + + // + // Constructors + // + + CDbColumnNode() : CDbCmdTreeNode(DBOP_column_name) + { + wKind = DBVALUEKIND_ID; + CDbColId * pTemp = new CDbColId(); + if ( pTemp ) + { + value.pdbidValue = pTemp->CastToStruct(); + } + } + + CDbColumnNode( GUID const & guidPropSet, PROPID pidProperty ) + : CDbCmdTreeNode(DBOP_column_name) + { + wKind = DBVALUEKIND_ID; + CDbColId * pTemp = new CDbColId( guidPropSet, pidProperty ); + if ( pTemp ) + { + value.pdbidValue = pTemp->CastToStruct(); + } + } + + CDbColumnNode( GUID const & guidPropSet, WCHAR const * wcsProperty ); + + // The fIMeanIt param is to avoid confusion when methods expect + // and CDbColumnNode, a DBID is passed, and automatically coerced + // but the memory allocation not checked. + + CDbColumnNode( DBID const & propSpec, BOOL fIMeanIt ); + + // + // Copy constructors/assignment/clone + // + CDbColumnNode( CDbColumnNode const & Property ) + : CDbCmdTreeNode(DBOP_column_name) + { + wKind = DBVALUEKIND_ID; + CDbColId* pTemp = new CDbColId(); + if ( pTemp ) + { + value.pdbidValue = pTemp->CastToStruct(); + operator=( Property ); + } + } + + CDbColumnNode & operator=( CDbColumnNode const & rhs ) + { + *(GetId()) = *(rhs.GetId()); + return *this; + } + + // + // Comparators + // + int operator==( CDbColumnNode const & rhs ) const + { + return *(GetId()) == *(rhs.GetId()); + } + + int operator!=( CDbColumnNode const & prop ) const + { + return !operator==(prop); + } + + // + // Member variable access + // + void SetPropSet( GUID const & guidPropSet ) + { + GetId()->SetPropSet( guidPropSet ); + } + + GUID const & GetPropSet() const + { + return GetId()->GetPropSet(); + } + + void SetProperty( PROPID pidProperty ) + { + GetId()->SetProperty( pidProperty ); + } + + BOOL SetProperty( WCHAR const * wcsProperty ) + { + return GetId()->SetProperty( wcsProperty ); + } + + WCHAR const * GetPropertyName() const + { + return GetId()->GetPropertyName(); + } + + PROPID GetPropertyPropid() const + { + return GetId()->GetPropertyPropid(); + } + + // PROPSPEC GetPropSpec() const; + + BOOL IsPropertyName() const + { + return GetId()->IsPropertyName(); + } + + BOOL IsPropertyPropid() const + { + return GetId()->IsPropertyPropid(); + } + + void SetCommandType( DBCOMMANDOP opVal ) + { + CDbCmdTreeNode::SetCommandType( opVal ); + } + + BOOL IsValid() + { + CDbColId * pId = GetId(); + return (0 != pId) ? pId->IsValid() : FALSE; + } + + CDbColId * GetId() + { + return (CDbColId *) value.pdbidValue; + } + + CDbColId const * GetId() const + { + return (CDbColId const *) value.pdbidValue; + } + +private: + +}; + + + +//+--------------------------------------------------------------------------- +// +// Class: CDbScalarValue +// +// Purpose: A DBCOMMANDTREE node representing a scalar constant +// +// History: 6-07-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbScalarValue : public CDbCmdTreeNode +{ + +public: + + CDbScalarValue( ULONG opVal = DBOP_scalar_constant ) : + CDbCmdTreeNode( opVal ) + { + } + + CDbScalarValue( const CStorageVariant & val ) : + CDbCmdTreeNode( DBOP_scalar_constant, DBVALUEKIND_VARIANT ) + { + CStorageVariant * pTemp = new CStorageVariant( val ); + if ( 0 != pTemp && !pTemp->IsValid() ) + { + delete pTemp; + pTemp = 0; + } + + if ( pTemp ) + { + value.pvarValue = (VARIANT *) (void *)pTemp; + } + } + + void SetValue( const CStorageVariant & val ) + { + CStorageVariant * lhs = _CreateOrGetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = val; + } + } + + void SetValue( double dValue ) + { + CStorageVariant * pTemp = _GetStorageVariant(); + if ( 0 != pTemp ) + { + *pTemp = dValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_R8; + value.dblValue = dValue; + } + } + + void SetValue( ULONG ulValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + lhs->SetUI4(ulValue); + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_UI4; + value.ulValue = ulValue; + } + } + + void SetValue( LONG lValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = lValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_I4; + value.lValue = lValue; + } + } + + void SetValue( LARGE_INTEGER llValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = llValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_I8; + value.llValue = (hyper) llValue.QuadPart; + } + } + + void SetValue( ULARGE_INTEGER ullValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + lhs->SetUI8(ullValue); + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_UI8; + value.ullValue = (unsigned hyper) ullValue.QuadPart; + } + } + + void SetValue( FILETIME ftValue ) + { + CStorageVariant * lhs = _CreateOrGetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = ftValue; + } + } + + void SetValue( CY CyValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = CyValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_CY; + value.cyValue = CyValue; + } + } + + void SetValue( float fValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = fValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_R4; + value.flValue = fValue; + } + } + + void SetValue( SHORT sValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = sValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_I2; + value.sValue = sValue; + } + } + + void SetValue( USHORT usValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = usValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_UI2; + value.usValue = usValue; + } + } + + void SetDate ( DATE dValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = dValue; + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_DATE; + value.dateValue = dValue; + } + } + + void SetBOOL( BOOL fValue ) + { + CStorageVariant * lhs = _GetStorageVariant(); + if ( 0 != lhs ) + { + lhs->SetBOOL(fValue); + } + else + { + CleanupValue(); + wKind = DBVALUEKIND_BOOL; + value.fValue = fValue; + } + } + + void SetValue( BLOB & bValue ) + { + CStorageVariant * lhs = _CreateOrGetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = bValue; + } + } + + void SetValue( WCHAR * pwcsValue ) + { + CStorageVariant * lhs = _CreateOrGetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = pwcsValue; + } + } + + void SetValue( GUID * pguidValue) + { + CStorageVariant * lhs = _CreateOrGetStorageVariant(); + if ( 0 != lhs ) + { + *lhs = pguidValue; + } + } + + void Value( CStorageVariant & valOut ); + + BOOL IsValid(); + +private: + + CStorageVariant * _GetStorageVariant() + { + if ( DBVALUEKIND_VARIANT == wKind ) + { + return CastToStorageVariant( *value.pvarValue ); + } + else + return 0; + } + + CStorageVariant * _CreateOrGetStorageVariant() + { + + CStorageVariant * pTemp = _GetStorageVariant(); + if ( 0 != pTemp ) + { + return pTemp; + } + + CleanupValue(); + + wKind = DBVALUEKIND_VARIANT; + pTemp = new CStorageVariant(); + value.pvarValue = (VARIANT *) (void *) pTemp; + + return pTemp; + } +}; + +#define DBTABLEID_NAME L"Table" + +//+--------------------------------------------------------------------------- +// +// Class: CDbTableId +// +// Purpose: +// +// History: 6-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbTableId: public CDbCmdTreeNode +{ + +public: + + CDbTableId(const LPWSTR pwszName = DBTABLEID_NAME) + : CDbCmdTreeNode( DBOP_table_name ) + { + wKind = DBVALUEKIND_WSTR; + value.pwszValue = CDbCmdTreeNode::AllocAndCopyWString( pwszName ); + } + + BOOL IsValid() + { + return 0 != value.pwszValue; + } + + LPWSTR GetTableName() const + { + if (wKind == DBVALUEKIND_WSTR) + return value.pwszValue; + else + return 0; + } +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbSelectNode +// +// Purpose: +// +// History: 6-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbSelectNode : public CDbCmdTreeNode +{ + +public: + CDbSelectNode( ); + + BOOL AddRestriction( CDbCmdTreeNode * pRestr ) + { + if ( IsValid() && + GetFirstChild() && + GetFirstChild()->GetNextSibling() == 0 ) + { + AppendChild( pRestr ); + return TRUE; + } + else + { + return FALSE; + } + } + + BOOL SetRestriction( CDbCmdTreeNode * pRestr ); + + BOOL IsValid() + { + return 0 != GetFirstChild() && + GetFirstChild()->IsOpValid( DBOP_table_name ); + } +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbListAnchor +// +// Purpose: +// +// History: 6-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbListAnchor : public CDbCmdTreeNode +{ + +public: + + CDbListAnchor( DBCOMMANDOP opVal, WORD wType = DBVALUEKIND_EMPTY ) + : CDbCmdTreeNode( opVal, wType ) {} + +// BUGBUG - make these protected; call from CDbSortListAnchor and +// CDbProjectListAnchor with appropriate list element types. + BOOL AppendListElement( CDbCmdTreeNode* pListElement ); + + BOOL AppendListElement( ULONG eleType, + DBID const & PropSpec); + + BOOL AppendListElement( ULONG eleType, + GUID const & guidPropSet, PROPID pidProperty ); + + BOOL AppendListElement( ULONG eleType, + GUID const & guidPropSet, + WCHAR const * wcsProperty ); + + BOOL AppendListElement( ULONG eleType, const CDbColumnNode & propSpec ) + { + BOOL fSuccess = FALSE; + + CDbColumnNode * pTemp = new CDbColumnNode( propSpec ); + if ( 0 != pTemp ) + { + if (!_AppendListElement( eleType, pTemp ) ) + { + delete pTemp; + } + else + { + fSuccess = TRUE; + } + } + + return fSuccess; + } + +private: + + BOOL _IsValidListElement( ULONG eleType ) const + { + if ( eleType == DBOP_sort_list_element ) + { + return TRUE; + } + else if ( eleType == DBOP_project_list_element ) + { + return TRUE; + } + + return FALSE; + } + + BOOL _AppendListElement( ULONG eleType, CDbColumnNode * pColNode ); + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbProjectListAnchor +// +// Purpose: +// +// History: 6-15-95 srikants Created +// +// Notes: This class is required by the implementation, but should +// be unneeded by clients +// +//---------------------------------------------------------------------------- + +class CDbProjectListAnchor : public CDbListAnchor +{ +public: + CDbProjectListAnchor() : CDbListAnchor( DBOP_project_list_anchor ) {} + +// BUGBUG - define and use a project list element class for these + void AppendSibling(CDbCmdTreeNode *pSibling) + { + CDbCmdTreeNode::AppendSibling(pSibling); + } + void InsertSibling(CDbCmdTreeNode *pSibling) + { + CDbCmdTreeNode::InsertSibling(pSibling); + } +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbProjectNode +// +// Purpose: +// +// History: 6-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbProjectNode : public CDbCmdTreeNode +{ + +public: + + CDbProjectNode( ) + : CDbCmdTreeNode( DBOP_project ) + { + } + + BOOL AddProjectColumn( GUID const & guidPropSet, PROPID pidProperty ) + { + CDbProjectListAnchor * pAnchor = _FindOrAddAnchor(); + if (pAnchor) + return pAnchor->AppendListElement( DBOP_project_list_element, guidPropSet, + pidProperty ); + else + return FALSE; + } + + BOOL AddProjectColumn( GUID const & guidPropSet, + WCHAR const * wcsProperty ) + { + CDbProjectListAnchor * pAnchor = _FindOrAddAnchor(); + if (pAnchor) + return pAnchor->AppendListElement( DBOP_project_list_element, guidPropSet, + wcsProperty ); + else + return FALSE; + } + + BOOL AddProjectColumn( DBID const & propSpec ) + { + CDbProjectListAnchor * pAnchor = _FindOrAddAnchor(); + if (pAnchor) + return pAnchor->AppendListElement( DBOP_project_list_element, propSpec ); + else + return FALSE; + } + + BOOL AddProjectColumn( CDbColumnNode const & propSpec ) + { + CDbProjectListAnchor * pAnchor = _FindOrAddAnchor(); + if (pAnchor) + return pAnchor->AppendListElement( DBOP_project_list_element, propSpec ); + else + return FALSE; + } + + BOOL AddTable( CDbCmdTreeNode * pTable ) + { + if ( 0 == GetFirstChild() || + 0 == GetFirstChild()->GetNextSibling()) + { + InsertChild(pTable); + return TRUE; + } + return FALSE; + } + +private: + CDbProjectListAnchor * _FindOrAddAnchor(); + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbSortListAnchor +// +// Purpose: +// +// History: 6-15-95 srikants Created +// +// Notes: This class is required by the implementation, but should +// be unneeded by clients +// +//---------------------------------------------------------------------------- + +class CDbSortListAnchor : public CDbListAnchor +{ +public: + CDbSortListAnchor() : CDbListAnchor( DBOP_sort_list_anchor ) {} + +private: + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbSortListElement +// +// Purpose: +// +// History: 17 Aug 1995 AlanW Created +// +// Notes: This class is required by the implementation, but should +// be unneeded by clients +// +//---------------------------------------------------------------------------- + +class CDbSortListElement : public CDbCmdTreeNode +{ + +public: + + CDbSortListElement( BOOL fDescending = FALSE, LCID locale = 0 ) : + CDbCmdTreeNode( DBOP_sort_list_element, + DBVALUEKIND_SORTINFO ) + { + value.pdbsrtinfValue = new CDbSortInfo( fDescending, locale ); + } + + void SetDirection( BOOL fDescending ) + { + GetSortInfo().SetDirection( fDescending ); + } + + void SetLocale( LCID locale ) + { + GetSortInfo().SetLocale(locale); + } + + BOOL GetDirection( ) const + { + return GetSortInfo().GetDirection(); + } + + LCID GetLocale( ) const + { + return GetSortInfo().GetLocale(); + } + + void AddColumn( CDbCmdTreeNode * pCol ) + { + InsertChild( pCol ); + } + + BOOL IsValid() const + { + return 0 != value.pdbsrtinfValue; + } + + CDbSortInfo & GetSortInfo() + { + return *((CDbSortInfo *) value.pdbsrtinfValue); + } + + CDbSortInfo const & GetSortInfo() const + { + return *((CDbSortInfo const *) value.pdbsrtinfValue); + } + +private: + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbSortNode +// +// Purpose: +// +// History: 6-15-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbSortKey; // forward referenced + +class CDbSortNode : public CDbCmdTreeNode +{ + +public: + + CDbSortNode() : CDbCmdTreeNode( DBOP_sort ) {} + + BOOL AddTable( CDbCmdTreeNode * pTable ) + { + if ( 0 == GetFirstChild() || + 0 == GetFirstChild()->GetNextSibling()) + { + InsertChild(pTable); + return TRUE; + } + return FALSE; + } + + BOOL AddSortColumn(DBID const & propSpec, + BOOL fDirection, + LCID locale = GetSystemDefaultLCID()); + + inline BOOL AddSortColumn( CDbSortKey const & sortkey ); + +private: + CDbSortListAnchor * _FindOrAddAnchor(); + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbNestingNode +// +// Purpose: Wrapper for the DBCOMMANDTREE nesting node. +// +// History: 06 Aug 1995 AlanW Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbNestingNode : public CDbCmdTreeNode +{ + +public: + CDbNestingNode() : CDbCmdTreeNode( DBOP_nesting ) {} + + BOOL AddTable( CDbCmdTreeNode * pTable ); + + BOOL AddGroupingColumn( DBID const & propSpec, LCID locale = 0 ) + { + CDbProjectListAnchor * pAnchor = _FindGroupListAnchor(); + if (pAnchor) + return pAnchor->AppendListElement( DBOP_project_list_element, propSpec ); + else + return FALSE; + } + + BOOL AddParentColumn( DBID const & propSpec ) + { + CDbProjectListAnchor * pAnchor = _FindParentListAnchor(); + if (pAnchor) + return pAnchor->AppendListElement( DBOP_project_list_element, propSpec ); + else + return FALSE; + } + + BOOL AddChildColumn( DBID const & propSpec ) + { + CDbProjectListAnchor * pAnchor = _FindChildListAnchor(); + if (pAnchor) + return pAnchor->AppendListElement( DBOP_project_list_element, propSpec ); + else + return FALSE; + } + +private: + CDbProjectListAnchor * _FindGroupListAnchor(); + + CDbProjectListAnchor * _FindParentListAnchor() + { + CDbProjectListAnchor * pAnchor = _FindGroupListAnchor(); + if (pAnchor) + pAnchor = (CDbProjectListAnchor *)pAnchor->GetNextSibling(); + return pAnchor; + } + + CDbProjectListAnchor * _FindChildListAnchor() + { + CDbProjectListAnchor * pAnchor = _FindParentListAnchor(); + if (pAnchor) + pAnchor = (CDbProjectListAnchor *)pAnchor->GetNextSibling(); + return pAnchor; + } + +}; + + + +//+--------------------------------------------------------------------------- +// +// Class: CDbRestriction +// +// Purpose: +// +// History: 6-07-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbRestriction : public CDbCmdTreeNode +{ + +public: + + CDbRestriction( DBCOMMANDOP opVal = DBOP_DEFAULT ) : CDbCmdTreeNode( opVal ) + { + + } + + void SetOperator( DBCOMMANDOP opVal ) + { + op = opVal; + } + +private: + + +}; + +//+------------------------------------------------------------------------- +// +// Class: CDbNodeRestriction +// +// Purpose: Boolean AND/OR/VECTOR restriction +// +// History: 31-Dec-93 KyleP Created +// +//-------------------------------------------------------------------------- + +class CDbNodeRestriction : public CDbRestriction +{ + +public: + + // + // Constructors + // + CDbNodeRestriction( DBCOMMANDOP opVal ) : CDbRestriction( opVal ) {} + + // + // Manipulating the tree. + // + void AppendChild( CDbRestriction *pChild ) { + CDbRestriction::AppendChild( pChild ); + } + + void InsertChild( CDbRestriction *pChild ) { + CDbRestriction::InsertChild( pChild ); + } + +private: + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbNotRestriction +// +// Purpose: +// +// History: 6-07-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbNotRestriction : public CDbRestriction +{ + +public: + + // + // Constructors + // + + CDbNotRestriction() : CDbRestriction( DBOP_not ) + { + + } + + CDbNotRestriction( CDbRestriction * pres ) : CDbRestriction( DBOP_not ) + { + InsertChild( pres ); + } + + // + // Node manipulation + // + + void SetChild( CDbRestriction * pres ) + { + delete RemoveFirstChild(); + InsertChild( pres ); + } + + CDbRestriction * GetChild() + { + return (CDbRestriction *) GetFirstChild(); + } +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbPropBaseRestriction +// +// Purpose: Base class for CDbPropertyRestriction and +// CDbContentBaseRestriction. Provides access to the +// property child node. +// +// History: 26 Jul 1995 AlanW Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbPropBaseRestriction : public CDbRestriction +{ +public: + + // + // Constructors + // + CDbPropBaseRestriction( DBCOMMANDOP opVal = DBOP_DEFAULT ) : + CDbRestriction(opVal) {} + + // + // Child node access + // + + BOOL SetProperty( DBID const & Property ); + BOOL SetProperty( CDbColumnNode const & Property ); + CDbColumnNode const * GetProperty(); +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbPropertyRestriction +// +// Purpose: Restriction for relational operators, and "like" operator +// +// History: 6-07-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbPropertyRestriction : public CDbPropBaseRestriction +{ +public: + + // + // Constructors + // + CDbPropertyRestriction( ) : CDbPropBaseRestriction() {} + + CDbPropertyRestriction( ULONG relop, + DBID const & Property, + CStorageVariant const & prval ); + + CDbPropertyRestriction( ULONG relop, + CDbColumnNode const & Property, + CStorageVariant const & prval ); + // + // Member variable access + // + + void SetRelation( ULONG relop ) + { +// Win4Assert(relop >= DBOP_is_NOT_NULL); + if ( DBOP_like == relop ) + _SetLikeRelation(); + else + op = relop; + } + + ULONG Relation() + { + return op; + } + + BOOL SetValue( double dValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( dValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( ULONG ulValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( ulValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( LONG lValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( lValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( LARGE_INTEGER llValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( llValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( FILETIME ftValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( ftValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( CY CyValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( CyValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( float fValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( fValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( SHORT sValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( sValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( USHORT usValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( usValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( const CStorageVariant &prval ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( prval ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetDate ( DATE dValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( dValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetBOOL( BOOL fValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetBOOL( fValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( BLOB & bValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( bValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( WCHAR * pwcsValue ) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( pwcsValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL SetValue( GUID * pguidValue) + { + CDbScalarValue * pValue = _FindOrAddValueNode(); + if (pValue) { + pValue->SetValue( pguidValue ); + return TRUE; + } + else + return FALSE; + } + + BOOL IsOfsDialect(); + +private: + void _SetLikeRelation( ); + + void _CleanValue(); + BOOL _IsRelop( ULONG op ); + CDbScalarValue * _FindValueNode(); + CDbScalarValue * _FindOrAddValueNode(); +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbVectorRestriction () +// +// Purpose: +// +// History: 6-11-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbVectorRestriction : public CDbNodeRestriction +{ + +public: + + // + // Constructors + // + + CDbVectorRestriction( ULONG ulRankMethod ) + : CDbNodeRestriction( DBOP_content_vector_or ) + { + SetValueType( DBVALUEKIND_CONTENTVECTOR ); + CDbContentVector * pTemp = new CDbContentVector( ulRankMethod ); + if ( pTemp ) + { + value.pdbcntntvcValue = pTemp->CastToStruct(); + } + } + + // + // Member variable access + // + void SetRankMethod( ULONG ulRankMethod ) + { + CDbContentVector * pVector = GetContentVector(); + pVector->SetRankMethod( ulRankMethod ); + } + + ULONG RankMethod() const + { + CDbContentVector const * pVector = GetContentVector(); + return pVector->RankMethod(); + } + + ULONG GetWeightCount() + { + CDbContentVector * pVector = GetContentVector(); + return pVector->GetWeightCount(); + } + + ULONG const * GetWeights() + { + CDbContentVector * pVector = GetContentVector(); + return pVector->GetWeights(); + } + + void SetWeights( ULONG c, ULONG const *pul ) + { + CDbContentVector * pVector = GetContentVector(); + pVector->SetWeights( c, pul ); + } + + BOOL IsValid() const + { + return ( ( 0 != GetContentVector() ) && + ( GetContentVector()->IsValid() ) ); + } + + CDbContentVector * GetContentVector() + { + return (CDbContentVector *) value.pdbcntntvcValue; + } + + CDbContentVector const * GetContentVector() const + { + return (CDbContentVector const *) value.pdbcntntvcValue; + } +private: + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbContentBaseRestriction +// +// Purpose: +// +// History: 6-13-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbContentBaseRestriction : public CDbPropBaseRestriction +{ + +public: + + BOOL SetPhrase( const WCHAR * pwcsPhrase ) + { + return GetDbContent()->SetPhrase( pwcsPhrase ); + } + + WCHAR const * GetPhrase() const + { + return GetDbContent()->GetPhrase(); + } + + void SetLocale( LCID locale ) + { + GetDbContent()->SetLocale( locale ); + } + + LCID GetLocale() const + { + return GetDbContent()->GetLocale(); + } + + ULONG GetWeight() const + { + return GetDbContent()->GetWeight(); + } + + void SetWeight( ULONG weight ) + { + GetDbContent()->SetWeight( weight ); + } + + BOOL IsValid() const + { + CDbContent const * pTemp = GetDbContent(); + return ( ( 0 != pTemp ) && + ( pTemp->IsValid() ) ); + } + +protected: + + CDbContentBaseRestriction( DBCOMMANDOP opVal, + DWORD fuzzyLevel = FUZZY_EXACT, + ULONG ulWeight = 0, + LCID lcid = 0, + const WCHAR * pwszPhrase = 0 + ) : CDbPropBaseRestriction( opVal ) + { + wKind = DBVALUEKIND_CONTENT; + CDbContent * pTemp = new CDbContent( fuzzyLevel, ulWeight, + lcid, pwszPhrase ); + value.pdbcntntValue = (DBCONTENT *) pTemp; + } + + BOOL _IsContentNode() + { + return DBOP_content == op || + DBOP_content_proximity == op || + DBOP_content_freetext == op || + DBOP_content_vector_or == op ; + } + + void _Cleanup() + { + CDbContent * pContent = GetDbContent(); + pContent->Cleanup(); + } + + CDbContent * GetDbContent() + { + return (CDbContent *) value.pdbcntntValue; + } + + CDbContent const * GetDbContent() const + { + return (CDbContent const *) value.pdbcntntValue; + } + +}; + +//+--------------------------------------------------------------------------- +// +// Class: CDbNatLangRestriction +// +// Purpose: +// +// History: 6-11-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbNatLangRestriction : public CDbContentBaseRestriction +{ + +public: + + CDbNatLangRestriction( const WCHAR * pwcsPhrase, + CDbColumnNode const & Property, + LCID lcid = GetSystemDefaultLCID() ); + + CDbNatLangRestriction( const WCHAR * pwcsPhrase, + DBID const & Property, + LCID lcid = GetSystemDefaultLCID() ); + +private: + +}; + + +//+--------------------------------------------------------------------------- +// +// Class: CDbContentRestriction +// +// Purpose: +// +// History: 6-11-95 srikants Created +// +// Notes: +// +//---------------------------------------------------------------------------- + +class CDbContentRestriction : public CDbContentBaseRestriction +{ + +public: + + CDbContentRestriction( const WCHAR * pwcsPhrase, + CDbColumnNode const & Property, + ULONG ulFuzzy = 0, + LCID lcid = GetSystemDefaultLCID() ); + + CDbContentRestriction( const WCHAR * pwcsPhrase, + DBID const & Property, + ULONG ulFuzzy = 0, + LCID lcid = GetSystemDefaultLCID() ); + + // + // Member variable access + // + + + void SetFuzzyLevel( ULONG ulFuzzy ) + { + GetDbContent()->SetFuzzyLevel( ulFuzzy ); + } + + ULONG FuzzyLevel() const { return GetDbContent()->GetFuzzyLevel(); } + +private: + +}; + + + +//+------------------------------------------------------------------------- +// +// Class: CDTopNode +// +// Purpose: Specifies a cap on the number of results +// +// History: 2-21-96 SitaramR Created +// +//-------------------------------------------------------------------------- + +class CDbTopNode : public CDbCmdTreeNode +{ + +public: + CDbTopNode() + : CDbCmdTreeNode( DBOP_top, DBVALUEKIND_UI4 ) + { + } + + void SetChild( CDbCmdTreeNode *pChild ) + { + AppendChild( pChild ); + } + + CDbCmdTreeNode *GetChild() + { + return GetFirstChild(); + } + + void SetValue( ULONG ulValue ) + { + value.ulValue = ulValue; + } + + ULONG GetValue() + { + return value.ulValue; + } +}; + + +//+------------------------------------------------------------------------- +// +// Class: CDbColumns +// +// Purpose: C++ wrapper for array of CDbColId +// +// History: 22-Jun-93 KyleP Created +// +//-------------------------------------------------------------------------- + +class CDbColumns +{ +public: + + // + // Constructors + // + + CDbColumns( unsigned size = 0 ); + + // + // Copy constructors/assignment/clone + // + + CDbColumns( CDbColumns const & src ); + CDbColumns & operator=( CDbColumns const & src ); + + // + // Destructor + // + + ~CDbColumns(); + + // + // Memory allocation + // + + void * operator new( size_t size ); + void operator delete( void * p ); + + // + // Serialization + // + + void Marshall( PSerStream & stm ) const; + CDbColumns( PDeSerStream & stm ); + + // + // C/C++ conversion + // + + inline DBID * GetColumnsArray() const; + + // + // Member variable access + // + + BOOL Add( CDbColId const & Property, unsigned pos ); + void Remove( unsigned pos ); + inline CDbColId const & Get( unsigned pos ) const; + + inline unsigned Count() const; + + BOOL IsValid() const + { + return _cCol ? 0 != _aCol : TRUE; + } + +private: + + unsigned _cCol; + CDbColId * _aCol; + unsigned _size; +}; + + +#if !defined(QUERY_SORTASCEND) + +#define QUERY_SORTASCEND ( 0 ) +#define QUERY_SORTDESCEND ( 1 ) + +#endif // !defined(QUERY_SORTASCEND) + +//+------------------------------------------------------------------------- +// +// Structure: CDbSortKey +// +// Purpose: sort key class, for convenience in building sort lists +// +//-------------------------------------------------------------------------- + +class CDbSortKey +{ +public: + + // + // Constructors + // + + inline CDbSortKey(); + inline CDbSortKey( CDbSortKey const & sk ); + inline CDbSortKey( CDbColId const & ps, DWORD dwOrder = QUERY_SORTASCEND); + inline CDbSortKey( CDbColId const & ps, DWORD dwOrder, LCID locale ); + + // + // Member variable access + // + + inline void SetProperty( CDbColId const & ps ); + inline CDbColId const & GetProperty() const; + inline DWORD GetOrder() const; + inline void SetOrder(DWORD dwOrder); + inline LCID GetLocale() const; + inline void SetLocale(LCID locale); + + // + // Serialization + // + + void Marshall( PSerStream & stm ) const; + CDbSortKey( PDeSerStream & stm ); + +private: + + CDbColId _property; + DWORD _dwOrder; + LCID _locale; +}; + + +//+------------------------------------------------------------------------- +// +// Class: CDbSortSet +// +// Purpose: C++ wrapper for array of CDbSortKeys +// +// History: 22-Jun-93 KyleP Created +// +//-------------------------------------------------------------------------- + +class CDbSortSet +{ +public: + + // + // Constructors + // + + CDbSortSet( unsigned size = 0 ); + + // + // Copy constructors/assignment/clone + // + + CDbSortSet( CDbSortSet const & src ); + CDbSortSet & operator=( CDbSortSet const & src ); + + // + // Destructor + // + + ~CDbSortSet(); + + // + // Memory allocation + // + + inline void * operator new( size_t size ); + inline void operator delete( void * p ); + + // + // Serialization + // + + void Marshall( PSerStream & stm ) const; + CDbSortSet( PDeSerStream & stm ); + + // + // Member variable access + // + + BOOL Add( CDbSortKey const &sk, unsigned pos ); + BOOL Add( CDbColId const & Property, ULONG dwOrder, unsigned pos ); + void Remove( unsigned pos ); + inline CDbSortKey const & Get( unsigned pos ) const; + + inline unsigned Count() const; + +private: + + unsigned _csk; + CDbSortKey * _ask; + unsigned _size; +}; + + +// +// Inline methods for CDbColumns +// + +inline CDbColId const & CDbColumns::Get( unsigned pos ) const +{ + if ( pos < _cCol ) + return( _aCol[pos] ); + else + return( *(CDbColId *)0 ); +} + +inline void * CDbColumns::operator new( size_t size ) +{ + void * p = CoTaskMemAlloc( size ); + + return( p ); +} + +inline void CDbColumns::operator delete( void * p ) +{ + if ( p ) + CoTaskMemFree( p ); +} + +inline unsigned CDbColumns::Count() const +{ + return( _cCol ); +} + +inline DBID * CDbColumns::GetColumnsArray() const +{ + return _aCol; +} + + +// +// Inline methods for CDbSortKey +// + +inline CDbSortKey::CDbSortKey() +{ +} + +inline CDbSortKey::CDbSortKey( CDbSortKey const & sk ) + : _property( sk._property ), + _dwOrder( sk._dwOrder ), + _locale( sk._locale ) +{ +} + +inline CDbSortKey::CDbSortKey( CDbColId const & ps, ULONG dwOrder ) + : _property( ps ), + _dwOrder( dwOrder ), + _locale( 0 ) +{ +} + +inline CDbSortKey::CDbSortKey( CDbColId const & ps, ULONG dwOrder, LCID locale ) + : _property( ps ), + _dwOrder( dwOrder ), + _locale ( locale ) +{ +} + + +inline void CDbSortKey::SetProperty( CDbColId const & ps ) +{ + _property = ps; +} + +inline void CDbSortKey::SetLocale( LCID locale ) +{ + _locale = locale; +} + +inline void CDbSortKey::SetOrder( DWORD dwOrder ) +{ + _dwOrder = dwOrder; +} + +inline CDbColId const & CDbSortKey::GetProperty() const +{ + return( _property ); +} + +inline LCID CDbSortKey::GetLocale() const +{ + return( _locale ); +} + +inline DWORD CDbSortKey::GetOrder() const +{ + return( _dwOrder ); +} + +// +// Inline methods of CDbSortSet +// + +inline void * CDbSortSet::operator new( size_t size ) +{ + void * p = CoTaskMemAlloc( size ); + + return( p ); +} + +inline void CDbSortSet::operator delete( void * p ) +{ + if ( p ) + CoTaskMemFree( p ); +} + +inline CDbSortKey const & CDbSortSet::Get( unsigned pos ) const +{ + if ( pos < _csk ) + { + return( _ask[pos] ); + } + else + { + return( *(CDbSortKey *)0 ); + } +} + +inline unsigned +CDbSortSet::Count() const +{ + return( _csk ); +} + +// +// Inline methods of CDbSortNode (needs defn. of CDbSortKey) +// +inline BOOL +CDbSortNode::AddSortColumn( CDbSortKey const & sortkey ) +{ + return AddSortColumn( sortkey.GetProperty(), + sortkey.GetOrder() == QUERY_SORTDESCEND, + sortkey.GetLocale() ); +} + +#endif // __DBCMDTRE_HXX__ |