// 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 );