3772 lines
76 KiB
C++
3772 lines
76 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// 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__
|