// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "U32STD.H"

 #include <d32dbms.h>

 #include "D32REC.H"

 #include "D32TABLE.H"

 #include "D32SQL.H"

 #include <s32mem.h>

 /**

 @internalComponent

 */

 enum TTablePanic

 	{

 	EDbInvalidColumn,

 	EDbWrongType,

 	EDbInUpdate,

 	EDbNotInUpdate,

 	EDbInvalidRow,

 	EDbRowNotRead,

 	EDbReadOnly,

 	EDbTableOpen,

 	EDbNotEvaluated,

 	EDbStreamOpen,

 	EDbRowSetConstraintMismatch,

 	EDbBeginNestedTransaction,

 	EDbUpdatesPendingOnCommit,

 	EDbUpdatesPendingOnRollback,

 	EDbNoCurrentTransaction,

 	EDbStreamsPendingOnCommit,

 	EDbStreamsPendingOnRollback,

 	EDbInvalidBookmark

 	};

 /**

 @internalComponent

 */

 GLREF_C void Panic( TTablePanic aPanic );

 class Validate

 /**

 @internalComponent

 */

 	{

 public:

 	static void NameL( const TDesC& aName );

 	static void ColSetL( const CDbColSet& aColSet );

 	static void KeyL( const CDbKey& aKey, const HDbColumnSet& aColumns );

 private:

 	static void UniqueNameL( TDesC const** aNames, TInt aCount, const TDesC& aName );

 	};

 class CDbDataSource : public CBase

 /**

 @internalComponent

 */

 	{

 public:

 	enum TGoto { ESuccess, ENoRow, EExhausted, ESynchFailure };

 	enum TSynch { ESynch, ENoSynch };

 	enum TDelete { EDeletedAtNext, EDeletedAtEnd, EDeletedInLimbo };

 	enum TWrite { EReplace, EAppend };

 protected:

 	enum { EWorkToIterate = 1, EWorkToRead = 16 };

 public:

 	virtual RDbRow* RowBuffer() = 0;

 	virtual TDbColumn Column( TDbColNo aColNo ) = 0;

 	virtual void Reset() = 0;

 	virtual TBool EvaluateL( TInt& aWork, TDbRecordId& aRecordId, TBool& aAtRow ) = 0;

 	virtual TBool Unevaluated() = 0;

 	virtual TInt CountL() = 0;

 	virtual TGoto GotoL( TInt& aWork, TDbPosition aPosition, TDbRecordId& aRecordId ) = 0;

 	TGoto GotoL( TDbPosition aPosition, TDbRecordId& aRecordId );

 	virtual TBool GotoL( TDbRecordId aRecordId ) = 0;

 	virtual void ReadRowL( TDbRecordId aRecordId ) = 0;

 	virtual void NewRowL( TDbRecordId aCopyRecord ) = 0;

 	virtual void PrepareToWriteRowL( TWrite aWrite ) = 0;

 	virtual TDbRecordId WriteRowL( TWrite aWrite, TSynch aSynch = ESynch ) = 0;

 	virtual TDelete DeleteRowL( TDbRecordId& aRecordId, TSynch aSynch = ESynch ) = 0;

 	virtual TInt ColumnCount() const = 0;

 	virtual const TDbColumnDef& ColumnDef( TDbColNo aCol ) const = 0;

 //

 	virtual void SetIndexL( const TDesC* anIndex ) = 0;

 	virtual TBool SeekL( const TDbLookupKey& aKey, RDbTable::TComparison aComparison, TDbRecordId& aRecordId ) = 0;

 	virtual CSqlSearchCondition* ParseConstraintLC( const TDesC& aCondition ) = 0;

 protected:

 	CDbDataSource() {};

 	};

 NONSHARABLE_CLASS(CDbTableSource) : public CDbDataSource

 /**

 @internalComponent

 */

 	{

 public:

 	~CDbTableSource();

 	CDbTableSource();

 	void Construct( CDbTable* aTable );

 	inline void SetIterator( CDbRecordIter* anIter );

 	void ReverseIteratorL();

 	inline const RDbTableRow& Row();

 	inline CDbTable& Table();

 //

 	RDbRow* RowBuffer();

 	TDbColumn Column( TDbColNo aColNo );

 	void Reset();

 	TBool EvaluateL( TInt& aWork, TDbRecordId& aRecordId, TBool& aAtRow );

 	TBool Unevaluated();

 	TInt CountL();

 	TGoto GotoL( TInt& aWork, TDbPosition aPosition, TDbRecordId& aRecordId );

 	TBool GotoL( TDbRecordId aRecordId );

 	void NewRowL( TDbRecordId aCopyRecord );

 	void PrepareToWriteRowL( TWrite aWrite );

 	TDbRecordId WriteRowL( TWrite aWrite, TSynch aSynch );

 	void ReadRowL( TDbRecordId aRecordId );

 	TDelete DeleteRowL( TDbRecordId& aRecordId, TSynch aSynch );

 	TInt ColumnCount() const;

 	const TDbColumnDef& ColumnDef( TDbColNo aCol ) const;

 	void SetIndexL( const TDesC* anIndex );

 	TBool SeekL( const TDbLookupKey& aKey, RDbTable::TComparison aComparison, TDbRecordId& aRecordId );

 	CSqlSearchCondition* ParseConstraintLC( const TDesC& aCondition );

 private:

 	TBool SynchL( TDbRecordId aRecordId );

 	void OpenIteratorL();

 private:

 	CDbRecordIter* iIter;

 	TDbGenerationMark iIterMark;

 	RDbTableRow iRow;

 	TBool iReset;

 	};

 NONSHARABLE_CLASS(CDbDataStage) : public CDbDataSource

 /**

 @internalComponent

 */

 	{

 public:

 	~CDbDataStage();

 	inline void SetSource( CDbDataSource* aSource );

 protected:

 	CDbDataStage() {};

 	inline CDbDataSource& Source();

 	inline const CDbDataSource& Source() const;

 	RDbRow* RowBuffer();

 	TDbColumn Column( TDbColNo aColNo );

 	void Reset();

 	TBool EvaluateL( TInt& aWork, TDbRecordId& aRecordId, TBool& aAtRow );

 	TBool Unevaluated();

 	TInt CountL();

 	TGoto GotoL( TInt& aWork, TDbPosition aPosition, TDbRecordId& aRecordId );

 	TBool GotoL( TDbRecordId aRecordId );

 	void ReadRowL( TDbRecordId aRecordId );

 	void NewRowL( TDbRecordId aCopyRecord );

 	void PrepareToWriteRowL( TWrite aWrite );

 	TDbRecordId WriteRowL( TWrite aWrite, TSynch aSynch );

 	TDelete DeleteRowL( TDbRecordId& aRecordId, TSynch aSynch );

 	TInt ColumnCount() const;

 	const TDbColumnDef& ColumnDef( TDbColNo aCol ) const;

 	void SetIndexL( const TDesC* anIndex );

 	TBool SeekL( const TDbLookupKey& aKey, RDbTable::TComparison aComparison, TDbRecordId& aRecordId );

 	CSqlSearchCondition* ParseConstraintLC( const TDesC& aCondition );

 private:

 	CDbDataSource* iSource;

 	};

 NONSHARABLE_CLASS(CDbRestrictStage) : public CDbDataStage

 /**

 @internalComponent

 */

 	{

 public:

 	CDbRestrictStage( TDbTextComparison aComparison );

 	~CDbRestrictStage();

 	inline void SetRestriction( CSqlSearchCondition* aRestriction );

 private:

 	inline CSqlSearchCondition& Restriction() const;

 	TBool FilterRowL( TDbRecordId aRecordId );

 //

 	TInt CountL();

 	TGoto GotoL( TInt& aWork, TDbPosition aPosition, TDbRecordId& aRecordId );

 	TBool GotoL( TDbRecordId aRecordId );

 	TDelete DeleteRowL( TDbRecordId& aRecordId, TSynch aSynch );

 private:

 	CSqlSearchCondition* iRestriction;

 	const TTextOps& iTextOp;

 	};

 class HDbColumnMap;

 NONSHARABLE_CLASS(CDbProjectStage) : public CDbDataStage

 /**

 implement restricted column selection

 @internalComponent

 */

 	{

 public:

 	CDbProjectStage();

 	~CDbProjectStage();

 	void ConstructL( const RSqlColumnList& aSelect, const HDbColumnSet& aColumns );

 private:

 	RDbRow* RowBuffer();

 	TDbColumn Column( TDbColNo aColNo );

 	TInt ColumnCount() const;

 	const TDbColumnDef& ColumnDef( TDbColNo aCol ) const;

 private:

 	HDbColumnMap* iMap;

 	};

 NONSHARABLE_CLASS(CDbBasicWindowStage) : public CDbDataStage

 /**

 @internalComponent

 */

 	{

 private:

 	enum { EWindowArrayGranularity = 32 };	// 128 byte segments

 public:

 	CDbBasicWindowStage( const TDbWindow& aWindow );

 protected:

 // from CDbDataStage

 	void Reset();

 	TBool EvaluateL( TInt& aWork, TDbRecordId& aRecordId, TBool& aAtRow );

 	TInt CountL();

 	TGoto GotoL( TInt& aWork, TDbPosition aPosition, TDbRecordId& aRecordId );

 	TBool GotoL( TDbRecordId aRecordId );

 	void ReadRowL( TDbRecordId aRecordId );

 	TDbRecordId WriteRowL( TWrite aWrite, TSynch aSynch );

 	TDelete DeleteRowL( TDbRecordId& aRecordId, TSynch aSynch );

 private:

 	TBool GetRecord( TDbRecordId& aRecordId );

 	TInt Find( TDbRecordId aRecordId, TInt& aPos );

 	virtual TBool DoEvaluateL( TInt& aWork ) = 0;

 protected:

 	TDbWindow iWindow;		// the window shape

 	CArrayFixSeg<TDbRecordId> iRecords;	// the window itself

 	TInt iPos;				// the iterator over the window

 	};

 NONSHARABLE_CLASS(CDbWindowStage) : public CDbBasicWindowStage

 /**

 @internalComponent

 */

 	{

 private:

 	enum TView { EBeginning, EMiddle, EEnd, EAll };

 	enum TIterPos { EAtBeginning, EAtEnd };

 public:

 	CDbWindowStage( const TDbWindow& aWindow );

 protected:

 	void Reset();

 	TBool DoEvaluateL( TInt& aWork );

 	TBool Unevaluated();

 private:

 	TInt WhatToEvaluate();

 	TDbPosition ResetIterToBeginningL();

 	TDbPosition ResetIterToEndL();

 	TDbPosition SetIteratorL( TInt anEval );

 	void ExtendAtBeginningL( TInt aRecords, TDbPosition aFirst, TInt& aWork );

 	void ExtendAtEndL( TInt aRecords, TDbPosition aFirst, TInt& aWork );

 private:

 	TIterPos iIterPos;		// where the underlying iterator is in our window

 	TView iView;			// what part of the underlying set we see through the window

 	};

 NONSHARABLE_CLASS(CDbReorderWindowStage) : public CDbBasicWindowStage

 /**

 @internalComponent

 */

 	{

 private:

 	enum TState { EReset, EEvaluate, EComplete, EFailed };

 	enum { EGranularity = 32 };

 public:

 	CDbReorderWindowStage();

 	~CDbReorderWindowStage();

 protected:

 	void Reset();

 	TBool DoEvaluateL( TInt& aWork );

 	TBool Unevaluated();

 private:

 	TBool ReadL( TInt& aWork, TDbPosition aNext );

 private:

 	TState iState;

 	RArray<TUint> iRows;

 	};

 NONSHARABLE_CLASS(CDbOrderByStage) : public CDbBasicWindowStage

 /**

 @internalComponent

 */

 	{

 private:

 	class HOrdering;

 	class CKeys;

 	enum TState { EReset, EEvaluate, ESort, EAdd, EComplete, EFailed };

 public:

 	CDbOrderByStage( const RDbTableRow& aRow );

 	~CDbOrderByStage();

 	void ConstructL( const CDbKey& aOrderBy );

 protected:

 	void Reset();

 	TBool DoEvaluateL( TInt& aWork );

 	TBool Unevaluated();

 private:

 	inline const RDbTableRow& Row();

 	inline CKeys& Keys();

 	inline const HOrdering& Order();

 //

 	TBool ReadL( TInt& aWork, TDbPosition aNext );

 private:

 	const RDbTableRow& iRow;

 	TState iState;

 	HOrdering* iOrder;

 	CKeys* iKeys;

 	};

 class RDbAccessPlan

 /**

 @internalComponent

 */

 	{

 public:

 	inline RDbAccessPlan( CSqlQuery* aQuery, TDbTextComparison aComparison );

 	inline RDbAccessPlan();

 	void BuildLC( CDbTableDatabase& aDatabase, RDbRowSet::TAccess aAccess, const TDbWindow& aWindow );

 	void BuildLC( CDbTableDatabase& aDatabase, const TDesC& aTable, RDbRowSet::TAccess aAccess );

 	inline CDbTable& Table();

 	inline CDbDataSource& Source();

 	inline CDbDataSource* Adopt();

 private:

 	class TPlan

 		{

 	public:

 		enum 

 			{

 			EOrder = 0x1, ERestrict = 0x2, EReorder = 0x4,

 			EIndex = 0x8, EBounded = 0x10,

 			EWindow = 0x20, EReverse = 0x40,

 			EMask = 0x1f

 			};

 		enum TType 

 			{

 			EPlanA = 0, EPlanB = 0, EPlanC = 0, EPlanD = 0, EPlanEF = 1, EPlanGH = 7, EPlanIJ = 2,

 			EPlanKL = 5, EPlanMN = 4, EPlanOP = 3, EPlanQR = 6, EPlanST = 8

 			};

 	public:

 		inline TPlan();

 		inline TBool operator!=( const TPlan& aPlan ) const;

 		TType Type() const;

 		static TInt OrderByPlan( const TPlan& aLeft, const TPlan& aRight );

 	public:

 		TUint iFlags;

 		const CDbTableIndexDef* iIndex;

 		CSqlCompPredicate* iLower;

 		CSqlCompPredicate* iUpper;		

 		};	

 private:

 	CDbTableSource* TableLC( CDbTableDatabase& aDatabase, const TDesC& aTable );

 	void Insert( CDbDataStage* aStage );

 	CDbRecordIter* IteratorL( const TPlan& aPlan );

 	CDbRecordIter* BoundedIteratorL( const TPlan& aPlan );

 	void RestrictionL();

 	void OrderByL( const RDbTableRow& aRowBuf );

 	void ProjectionL();

 	void WindowL( const TPlan& aPlan, const TDbWindow& aWindow );

 	static void Cleanup( TAny* aPtr );

 	TBool IsBoundedIteratorL( TPlan& aPlan, const CDbTableIndexDef* aIndex );

 	TBool IsIndexIteratorL( TPlan& aPlan, const CDbTableIndexDef* aIndex );

 	void EvaluateWindowStage( TPlan& aPlan );

 	void EvaluateReorderStage( TPlan& aPlan, const CDbTableIndexDef* aIndex );

 	void EvaluatePlansL();

 	void ChoosePlanL( TPlan& aPlan );

 	void PrepareQueryL( CDbTableSource* aSource );

 	TInt GetTightestRestrictionL( TPlan& aPlan, TPlan::TType aType );

 	TInt GetSmallestKeySize( TPlan& aPlan, TPlan::TType aType );

 	TInt IndexSpanL( const TPlan& aPlan );

 	void ReducePlans();

 	void CreateTableIteratorPlan( TPlan& aPlan );

 	TUint FindMatchL( const CDbTableIndexDef* aIndex );

 	TBool TextKeyL( const CDbKey& anOrder );

 private:

 	enum { EGranularity = 4 };

 	enum { EMatch = 0x1, EReverse = 0x2, ETruncated = 0x4 };

 	//

 	class TBounds;

 	class CDbCompPredicateList;

 private:

 	RArray<TPlan> iPlans;

 	CDbDataSource* iSource;

 	CDbTable* iTable;

 	TDbTextComparison iComparison;

 	CSqlQuery* iQuery;

 	TBool iWindow;

 	RDbRowSet::TAccess iAccess;

 	};

 class RDbAccessPlan::TBounds

 	{

 public:

 	TBounds( const TPlan& aPlan );

 private:

 	void GetLookupKey( const CSqlCompPredicate& aCompPredicate, TDbLookupKey& aLookup );

 	void SetLowerBounds();

 	void SetUpperBounds();

 public:

 	CSqlCompPredicate* iLowerPred;

 	CSqlCompPredicate* iUpperPred;		

 	TDbLookupKey iLowerKey;

 	TDbLookupKey iUpperKey;

 	TDbLookupKey* iLower;

 	TDbLookupKey* iUpper;

 	TUint iInclusion;

 	};

 class RDbAccessPlan::CDbCompPredicateList : public CArrayFixFlat<CSqlCompPredicate*>

 	{

 public:

 	enum

 		{

 		EAnd = 0x1,

 		ELess = 0x2,

 		ELessEqual = 0x4,

 		EEqual = 0x8,

 		EGreaterEqual = 0x10,

 		EGreater = 0x20,

 		ECompPred = ELess | ELessEqual | EEqual | EGreaterEqual | EGreater,

 		ENone = 0

 		};

 public:

 	static CDbCompPredicateList* NewLC( CSqlQuery& aQuery, TDbTextComparison aComparison, const CDbTableDef& aTableDef );

 	CSqlCompPredicate* CompPredicate( TDbColNo aColNo, TUint aType = ECompPred );

 	TUint Type( CSqlSearchCondition::TType aType ) const;

 	inline TBool IsRestriction();

 private:

 	inline CDbCompPredicateList( const CDbTableDef& aTableDef, TDbTextComparison aComparison );

 	void ConstructL( CSqlSearchCondition& aSeachCondition );

 	TBool IsIndexed( const TDesC& aColumnName );

 private:

 	enum { EGranularity = 4 };

 private:

 	const CDbTableDef& iTableDef;

 	TDbTextComparison iComparison;

 	TBool iRestriction;

 	};

 class CDbTable::TValid

 /**

 @internalComponent

 */

 	{

 public:

 	TValid(CDbTable& aTable);

 	TBool Reset();

 //

 	inline operator TAny*() const;

 	void CheckL() const;

 //

 	inline RDbTransaction& Transaction() const;

 	inline CDbTable& Table() const;

 private:

 	CDbTable& iTable;

 	TDbGenerationMark iRollback;

 	};

 NONSHARABLE_CLASS(CDbTableCursor) : public CDbCursor

 /**

 @internalComponent

 */

 	{

 public:

 	static CDbTableCursor* NewL( RDbAccessPlan& aPlan, RDbRowSet::TAccess aAccess );

 //

 	inline CDbBlobSpace& BlobsL() const;

 	inline void AddSink();

 	inline void ReleaseSink();

 	inline void AddSource();

 	inline void ReleaseSource();

 	void AddBlobSource();

 	void ReleaseBlobSource();

 private:

 	CDbTableCursor( RDbAccessPlan& aPlan, RDbRowSet::TAccess anAccess );

 	~CDbTableCursor();

 //

 	void Reset();

 	TBool EvaluateL();

 	void Evaluate( TRequestStatus& aStatus );

 	TBool Unevaluated();

 //

 	void SetIndexL( const TDesC* anIndex );

 	TBool SeekL( const TDbLookupKey& aKey, RDbTable::TComparison aComparison );

 	CDbRowConstraint* OpenConstraintL( const TDbQuery& aCriteria );

 	TBool MatchL( CDbRowConstraint& aConstraint );

 //

 	TInt CountL( RDbRowSet::TAccuracy aAccuracy );

 	TBool AtBeginning();

 	TBool AtEnd();

 	TBool AtRow();

 	TBool GotoL( RDbRowSet::TPosition aPosition );

 	void Bookmark( TDbBookmark::TMark& aMark );

 	void GotoL( const TDbBookmark::TMark& aMark );

 	void GetL();

 	void InsertL( TInsert aClearRow );

 	void UpdateL();

 	void Cancel();

 	void PutL();

 	void DeleteL();

 //

 	TInt ColumnCount();

 	TDbColType ColumnType( TDbColNo aCol );

 	void ColumnDef( TDbCol& aCol, TDbColNo aColNo );

 //

 	RDbRow* RowBuffer();

 	TDbColumnC ColumnC( TDbColNo aCol );	// non-writeable row buffer

 	TDbColumn Column( TDbColNo aCol );		// writeable row buffer

 	void SetNullL( TDbColNo aCol );

 	TInt ColumnSize( TDbColNo aCol );

 	MStreamBuf* ColumnSourceL( TDbColNo aCol );

 	MStreamBuf* ColumnSinkL( TDbColNo aCol );

 //

 	TDbColType Type( TDbColNo aCol ) const;

 	void ReplaceBlobL( TDbColumn& aColumn );

 	inline TBool InUpdate() const;

 	inline RDbTransaction& Transaction();

 	void CheckStateL() const;

 	void CheckReadL() const;

 	void CheckUpdateL() const;

 	void AssertValidRow() const;

 	void AssertNotInUpdate() const;

 	void AssertInUpdate() const;

 	void AssertNoStreams() const;

 private:

 	enum TState

 		{

 		ERowBeginning,

 		ERowOK,

 		ERowEnd,

 		ERowInvalid,

 		ERowDeletedAtNext,

 		ERowDeletedAtEnd,

 		ERowInLimbo

 		};	// keep these in same order as CDbDataSource::TDelete

 	enum

 		{

 		EUpdatable = 0x01,

 		EReadable = 0x02,

 		ERead = 0x04,

 		EUpdating = 0x08,

 		EInserting = 0x10,

 		EDirty = 0x20,

 		EWriteBuf = 0x40

 		};

 	enum { EMaxReadBuf = 255 };

 	class HColumns;

 	class CConstraint;

 	class HMemBuf;

 	class HWriteBuf;

 	class HReadBuf;

 	class HHeapBuf;

 private:

 	TUint8 iState;

 	TUint8 iFlags;

 	TUint8 iReadBuf;

 	CDbTable::TValid iValid;

 	CDbDataSource* iDataSource;

 	TDbRecordId iRecord;

 	HColumns* iColumns;

 	};

 NONSHARABLE_CLASS(CDbTableCursor::HWriteBuf) : public TDesBuf

 	{

 public:

 	static HWriteBuf* NewL( CDbTableCursor& aCursor, const TDbColumn& aColumn, TDbColType aType );

 private:

 	inline HWriteBuf( CDbTableCursor& aCursor, const TDbColumn& aColumn, TDbColType aType );

 	virtual inline ~HWriteBuf();

 	void ConstructL();

 //

 	inline TBool IsBinary() const;

 	void FlipL();

 // for MStreamBuf

 	void DoRelease();

 	void DoSynchL();

 	TInt DoReadL( TAny* aPtr, TInt aMaxLength );

 	TStreamTransfer DoReadL( MStreamInput& aInput, TStreamTransfer aTransfer );

 	void DoWriteL( const TAny* aPtr, TInt aLength );

 	TStreamTransfer DoWriteL( MStreamOutput& aOutput, TStreamTransfer aTransfer );

 	TStreamPos DoSeekL( TMark aMark, TStreamLocation aLocation, TInt aOffset );

 private:

 	CDbTableCursor& iCursor;

 	TDbColumn iColumn;

 	TDbColType iType;

 	TDbBlob* iBlob;

 	TPtr8 iInlineBuf;

 	TDbBlobId iBlobId;

 	TInt iSize;

 	MStreamBuf* iOverflowBuf;

 	};

 NONSHARABLE_CLASS(CDbTableCursor::HMemBuf) : public TMemBuf

 	{

 public:

 	static HMemBuf* NewL( CDbTableCursor& aCursor, const TDesC8& aDes );

 protected:

 	HMemBuf( CDbTableCursor& aCursor );

 	virtual inline ~HMemBuf();

 private:

 	void DoRelease();

 private:

 	CDbTableCursor& iCursor;

 	};

 class CDbTableCursor::HHeapBuf : public CDbTableCursor::HMemBuf

 	{

 public:

 	enum { EMaxBlobBuffer = 0x600 };	// 1.5K to match KDbsStreamBufSize

 public:

 	static HHeapBuf* NewL( CDbTableCursor& aCursor, const TDbBlob& aBlob, TDbColType aType );

 private:

 	inline HHeapBuf( CDbTableCursor& aCursor );

 private:

 	TUint8 iBuf[1];

 	};

 NONSHARABLE_CLASS(CDbTableCursor::HReadBuf) : public MStreamBuf

 	{

 public:

 	static HReadBuf* NewLC( CDbTableCursor& aCursor );

 	inline void Set( MStreamBuf* aHost );

 private:

 	inline HReadBuf( CDbTableCursor& aCursor );

 	virtual inline ~HReadBuf();

 // from MStreamBuf

 	void DoRelease();

 	TInt DoReadL( TAny* aPtr, TInt aMaxLength );

 	TStreamTransfer DoReadL( MStreamInput& aInput, TStreamTransfer aTransfer );

 	TStreamPos DoSeekL( TMark aMark, TStreamLocation aLocation, TInt aOffset );

 private:

 	CDbTableCursor& iCursor;

 	MStreamBuf* iHost;

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CIncremental) : public CDbSyncIncremental

 /**

 @internalComponent

 */

 	{

 protected:

 	enum { ELastStep = 1 };

 	enum TState { ERunning = 0, EFailed, ECommitted };

 public:

 	inline void Construct( CStepper* aStepper );

 protected:

 	CIncremental( RDbTransaction& aTransaction );

 	~CIncremental();

 	inline RDbTransaction& Transaction();

 	inline CDbTableDatabase& Database();

 	inline TBool IsCommitted() const;

 private:

 	TBool NextL( TInt& aStep );

 	virtual TInt DoNextL( TInt aStep );

 	virtual void DoLastL() =0;

 private:

 	RDbTransaction& iTransaction;

 	CStepper* iStepper;

 	TState iState;

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CIncrementalDDL) : public CDbTableDatabase::CIncremental

 /**

 @internalComponent

 */

 	{

 protected:

 	CIncrementalDDL( RDbTransaction& aTransaction );

 	~CIncrementalDDL();

 // from CIncremental

 	void DoLastL();

 	};

 class CDbTableDatabase::CCreateIndex : public CDbTableDatabase::CIncrementalDDL

 /**

 @internalComponent

 */

 	{

 public:

 	static CCreateIndex* NewLC( RDbTransaction& aTransaction );

 	TInt ConstructL( const CDbTableDef& aTable, const CDbTableIndexDef& anIndex );

 private:

 	inline CCreateIndex( RDbTransaction& aTransaction );

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CDropIndex) : public CDbTableDatabase::CIncrementalDDL

 /**

 @internalComponent

 */

 	{

 public:

 	static CDropIndex* NewL( RDbTransaction& aTransaction, const CDbTableDef& aTable, CDbTableIndexDef* anIndex, TInt& aStep );

 	~CDropIndex();

 private:

 	inline CDropIndex( RDbTransaction& aTransaction );

 private:

 	CDbTableIndexDef* iDef;

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CDropTable) : public CDbTableDatabase::CIncrementalDDL

 /**

 @internalComponent

 */

 	{

 public:

 	static CDropTable* NewL( RDbTransaction& aTransaction, CDbTableDef* aTable, TInt& aStep );

 	~CDropTable();

 private:

 	inline CDropTable( RDbTransaction& aTransaction );

 private:

 	CDbTableDef* iDef;

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CAlterTable) : public CDbTableDatabase::CIncrementalDDL

 /**

 @internalComponent

 */

 	{

 public:

 	static CAlterTable* NewL( RDbTransaction& aTransaction, CDbTableDef& aTable, const CDbColSet& aNewDef, TInt& aStep );

 	~CAlterTable();

 private:

 	inline CAlterTable( RDbTransaction& aTransaction, CDbTableDef& aDef );

 	void ConstructL( const CDbColSet& aNewDef, TInt& aStep );

 // from CIncremental

 	void DoLastL();

 private:

 	CDbTableDef& iDef;

 	HDbColumnSet* iNewSet;

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CUtility) : public CDbTableDatabase::CIncremental

 /**

 @internalComponent

 */

 	{

 public:

 	static CUtility* NewL( RDbTransaction& aTransaction, CDbDatabase::TUtility aType, TInt& aStep );

 	~CUtility();

 private:

 	inline CUtility( RDbTransaction& aTransaction, CDbDatabase::TUtility aType );

 private:

 	void DoLastL();

 	};

 NONSHARABLE_CLASS(CDbIncrementalDML) : public CDbSyncIncremental

 /**

 @internalComponent

 */

 	{

 public:

 	static CDbIncrementalDML* NewL( CSqlModifyStatement& aStatement, CDbTableDatabase& aDatabase, TDbTextComparison aComparison );

 	~CDbIncrementalDML();

 private:

 	enum TState { EInitialising = 0, EEvaluating, EUpdating, EDeleting, ECommitted, EFailed };

 private:

 	inline CDbIncrementalDML( RDbAccessPlan& aPlan );

 	inline RDbTransaction& Transaction();

 	inline TBool IsUpdate() const;

 	inline void	SetState( TState aState );

 // from CDbSyncIncremental

 	TBool NextL( TInt& aRows );

 private:

 	TState iState;

 	CDbTable& iTable;

 	CDbDataSource* iSource;

 	TDbRecordId iRecord;

 	CSqlValues* iValues;

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CInterface) : public CDbDatabase

 /**

 the interface implementation class for the Table database framework

 @internalComponent

 */

 	{

 public:

 	CInterface(CDbTableDatabase& aDatabase);

 private:

 	~CInterface();

 	inline CDbTableDatabase& Database();

 	void PrepareDDLL();

 //	from the interface framework

 	TInt Destroy();

 	TInt Begin();

 	TInt Commit();

 	void Rollback();

 	TInt Property( TProperty aProperty );

 	void CreateTableL( const TDesC& aName, const CDbColSet& aColSet, const CDbKey* aPrimaryKey );

 	void TablesL( CDbTableNames& aNames );

 	void ColumnsL( CDbColSet& aColSet, const TDesC& aName );

 	void IndexesL( CDbIndexNames& aNames, const TDesC& aTable );

 	void KeysL( CDbKey& aKey, const TDesC& aName, const TDesC& aTable );

 	CDbNotifier* OpenNotifierL();

 	CDbCursor* PrepareViewL( const TDbQuery& aQuery, const TDbWindow& aWindow, RDbRowSet::TAccess anAccess );

 	CDbCursor* OpenTableL( const TDesC& aName, RDbRowSet::TAccess anAccess );

 	CDbIncremental* OpenDropTableL( const TDesC& aTable, TInt& aStep );

 	CDbIncremental* OpenAlterTableL( const TDesC& aTable, const CDbColSet& aNewDef, TInt& aStep );

 	CDbIncremental* OpenCreateIndexL( const TDesC& aName, const TDesC& aTable, const CDbKey& aKey, TInt& aStep );

 	CDbIncremental* OpenDropIndexL( const TDesC& aName, const TDesC& aTable, TInt& aStep );

 	CDbIncremental* OpenUtilityL( CDbDatabase::TUtility aType, TInt& aStep );

 	CDbIncremental* OpenExecuteL( const TDesC& aSql, TDbTextComparison aComparison, TInt& aInit );

 private:

 	CDbTableDatabase& iDatabase;

 	};

 NONSHARABLE_CLASS(CDbTableDatabase::CSource) : public CDbSource

 /**

 @internalComponent

 */

 	{

 public:

 	CSource( CDbTableDatabase& aDatabase );

 private:

 	~CSource();

 	inline CDbTableDatabase& Database();

 	// from the framework

 	CDbDatabase* AuthenticateL();

 	CDbNotifier* OpenNotifierL();

 private:

 	CDbTableDatabase& iDatabase;

 	};

 #include "UT_STD.INL"