//+---------------------------------------------------------------------------
//
// 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__
