// 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:

//

#if !defined(__D32TABLE_H__)

#define __D32TABLE_H__

#if !defined(__D32DBAS_H__)

#include "D32DBAS.H"

#endif

#if !defined(__D32REC_H__)

#include "D32REC.H"

#endif

#if !defined(__D32CACHE_H__)

#include "D32CACHE.H"

#endif

// classes defined in this file

class TDbGenerationMark;

class TDbColumnDef;

class HDbColumnSet;

class CDbTableIndexDef;

class RDbIndexes;

class RDbTableSchema;

class CDbTableDef;

class RDbTableRow;

class CDbTable;

class RDbTables;

class RDbTransaction;

class CDbTableDatabase;

// classes also referenced

class CDbTableSource;

class CDbBlobCleanup;

/**

@internalComponent

*/

const TInt KDbTableMaxIndexes = 32;

/**

@internalComponent

*/

class CDbTableIndexDef : public CBase

	{

	friend class RDbIndexes;

public:

	IMPORT_C CDbTableIndexDef();

	IMPORT_C ~CDbTableIndexDef();

	IMPORT_C void ConstructL( const TDesC& aName );

	inline const TDesC& Name() const;

	inline const CDbKey& Key() const;

	inline CDbKey& Key();

private:

	TSglQueLink iLink;

	HBufC* iName;

	CDbKey iKey;

	};

/**

@internalComponent

*/

class RDbIndexes

	{

	friend class CDbTableDef;

public:

	inline void Add( CDbTableIndexDef* aDef );

	inline void Remove( CDbTableIndexDef* aDef );

	inline const TSglQueBase& AsQue() const;

	CDbTableIndexDef* Find( const TDesC& aName ) const;

	CDbTableIndexDef& FindL( const TDesC& aName ) const;

	IMPORT_C TInt Count() const;

private:

	inline RDbIndexes();

	void Close();

private:

	TSglQue<CDbTableIndexDef> iRep;

	};

/**

@internalComponent

*/

class TDbColumnDef

	{

public:

	IMPORT_C void SetL( const TDbCol& aCol );

	IMPORT_C void SetL( const TDbColumnDef& aCol );

	void AsTDbCol( TDbCol& aColumn ) const;

	inline TDbColType Type() const;

private:

// don't allow copies

	void operator=( const TDbColumnDef& );

public:

	// flags used by AlterTable

	enum { EDropped = 0x1, EChangedType = 0x2, EChangedLen = 0x4, EAdded = 0x8 };

public:

	HBufC* iName;

	TInt iMaxLength;

	TUint8 iType;

	TUint8 iAttributes;

	TUint8 iFlags;

	TUint8 iReserved;

	};

/**

@internalComponent

*/

class HDbColumnSet

	{

private:

	enum { ELongColumns = 0x1, EAutoIncrement = 0x2 };

public:

	typedef TDbColumnDef* TIterator;

	typedef const TDbColumnDef* TIteratorC;

public:

	static HDbColumnSet* NewL( TInt aCount );

	~HDbColumnSet();

//

	inline TIterator Begin();

	void Complete();

	IMPORT_C TInt Count() const;

	inline TIteratorC Begin() const;

	inline TIteratorC End() const;

	inline const TDbColumnDef& operator[]( TDbColNo anIndex ) const;

	IMPORT_C TIteratorC ColumnL( const TDesC& aColumn ) const;

	inline TIterator ColumnL( const TDesC& aColumn );

	IMPORT_C TDbColNo ColNoL( const TDesC& aColumn ) const;

	inline TBool HasLongColumns() const;

	inline TBool HasAutoIncrement() const;

private:

	HDbColumnSet( TInt aCount );

	const TIteratorC* IndexL() const;

private:

	TUint iAttributes;

	TIteratorC* iIndex;

	const TDbColumnDef* const iEnd;

	TDbColumnDef iColumns[1];		// at least one

	};

/**

@internalComponent

*/

class CDbTableDef : public CBase

	{

	friend class RDbTableSchema;

public:

	IMPORT_C ~CDbTableDef();

	inline const TDesC& Name() const;

	inline HDbColumnSet& Columns();

	inline const HDbColumnSet& Columns() const;

	inline RDbIndexes& Indexes();

	inline const RDbIndexes& Indexes() const;

	IMPORT_C virtual void Changed();

//

	inline const CDbTableIndexDef* Key( const TDesC& aColumn ) const;

	inline TBool IsIndexed( const TDesC& aColumn ) const;

//

	virtual void AlteredColumnSetL( HDbColumnSet& aSet, const CDbColSet& aChange, const CDbColSet& aAdd ) = 0;

	void ExchangeColumnSet( HDbColumnSet* aSet );

protected:

	IMPORT_C CDbTableDef();

	IMPORT_C void ConstructL( const TDesC& aName, TInt aColumnCount );

private:

	const CDbTableIndexDef* FindKey( const TDesC& aColumn, TBool aFirstColumn ) const;

private:

	TSglQueLink iLink;

	HBufC* iName;

	HDbColumnSet* iColumns;

	RDbIndexes iIndexes;

	};

/**

@internalComponent

*/

class RDbTableSchema

	{

	friend class CDbTableDatabase;

public:

	inline void Loaded();

	inline operator TSglQueBase&();

	inline void Add( CDbTableDef* aDef );

//

	inline TBool IsEmpty() const;

	CDbTableDef* Find( const TDesC& aTable );

	CDbTableDef& FindL( const TDesC& aTable );

private:

	inline RDbTableSchema();

	void Close();

//

	inline TBool IsLoaded() const;

	void Discard();

	inline void Remove( CDbTableDef* aDef );

private:

	TSglQue<CDbTableDef> iRep;

	TBool iLoaded;

	};

/**

@internalComponent

*/

typedef TUint TDbGeneration;

/**

@internalComponent

*/

class TDbGenerationMark

	{

public:

	inline void Construct( const TDbGeneration& aGeneration );

	inline void Mark();

	inline TBool Changed() const;

private:

	const TDbGeneration* iGeneration;

	TDbGeneration iMark;

	};

/**

@internalComponent

*/

class CDbTable : public CBase

	{

	friend class RDbTables;

public:

	class TValid;

	friend class TValid;

	enum { EUnavailableSpan = -1, EFullIndexSpan = 100 };

protected:

	IMPORT_C CDbTable( CDbTableDatabase& aDatabase, const CDbTableDef& aDef );

	IMPORT_C ~CDbTable();

public:

	void Open();

	void Close();

	void FlushL();

	void Abandon();

	void Release();

	void Idle();

//

	inline TBool IsActive() const;

	inline TBool IsIdle() const;

	inline const CDbTableDef& Def() const;

	inline CDbTableDatabase& Database();

//

	inline const TDbGeneration& Generation() const;

	TBool ExistsL( TDbRecordId aRecordId );

	void NewRowL( RDbRow& aRow );

	void ReadRowL( RDbRow& aRow, TDbRecordId aRecordId );

	void PrepareReplaceL( const RDbTableRow& aRow, TDbRecordId aRecordId );

	void ReplaceRowL( RDbTableRow& aRow, TDbRecordId aRecordId );

	void PrepareAppendL( const RDbTableRow& aRow );

	TDbRecordId AppendRowL( const RDbTableRow& aRow );

	void DeleteRowL( RDbTableRow& aRow, TDbRecordId aRecordId );

	void DuplicateBlobsL( RDbRow& aRow );

	IMPORT_C void DiscardBlobsL( RDbRow& aRow );

//

	IMPORT_C CDbRecordSpace& RecordsL();

	IMPORT_C CDbRecordIndex& IndexL( const CDbTableIndexDef& anIndex );

	IMPORT_C CDbBlobSpace* BlobsL();

	virtual CDbRecordIndex* RecordIndexL( const CDbTableIndexDef& anIndex ) = 0;

//

	CDbRecordIter* IteratorL();

	IMPORT_C virtual TInt IndexSpanL( const CDbTableIndexDef& aIndex, TUint aInclusion, const TDbLookupKey* aLowerBound, const TDbLookupKey* aUpperBound );

	CDbRecordIter* IteratorL( const CDbTableIndexDef& aIndex, TUint aInclusion = 0, const TDbLookupKey* aLowerBound = 0, const TDbLookupKey* aUpperBound = 0 );

	CDbRecordIter* IteratorL( const TDesC& aIndex );

private:

	typedef void ( *TBlobFuncL )( CDbBlobSpace& aBlobStore, TDbBlob& aBlob, TDbColType aType, CDbBlobCleanup* aCleanup );

private:

	inline void Discard();

	void Disconnect();

	inline TBool InUse() const;

	inline RDbCache& Cache();

//

	void ApplyToBlobsL( RDbRow& aRow, TBlobFuncL aFuncL, CDbBlobCleanup* aCleanup = 0 );

	void ApplyToComponentsL( void ( *anOperationL )( CDbRecordBase* ) );

	void EnsureIndexesL();

	void ValidateL( const RDbRow& aRow );

	void CheckInliningL( RDbRow& aRow );

	void DoReplaceRowL( const RDbRow& aRow, TDbRecordId aRecordId );

//

	virtual CDbRecordSpace* RecordSpaceL() = 0;

	virtual CDbBlobSpace* BlobSpaceL() = 0;

//

	virtual void CopyToRowL( RDbRow& aRow, const TDesC8& aRecord ) = 0;

	virtual TInt RecordLength( const RDbRow& aRow ) = 0;

	virtual void CopyFromRow( TUint8* aRecord, const RDbRow& aRow ) = 0;

private:

	enum { EIdle = -1, ECached = -2 };

private:

	TSglQueLink iLink;

	TInt iRef;

	CDbTableDatabase* iDatabase;

	const CDbTableDef* iDef;

	TDbGeneration iGeneration;

	CDbRecordSpace* iRecords;

	CDbBlobSpace* iBlobs;

	CDbRecordIndex* iIndexes[KDbTableMaxIndexes];

	CDbRecordIndex** iIndexesEnd;

	TUint32 iUpdateMap;

	};

/**

@internalComponent

*/

class RDbTableRow : public RDbRow

	{

public:

	inline RDbTableRow();

	void Open( CDbTable* aTable );

	void Close();

//

	inline CDbTable& Table() const;

	IMPORT_C void ReadL( TDbRecordId aRecordId );

	void NewL( TDbRecordId aCopyRecord );

	void PrepareAppendL();

	TDbRecordId AppendL();

	void PrepareReplaceL();

	TDbRecordId ReplaceL();

	void DeleteL( TDbRecordId aRecordId );

private:

	TDbGenerationMark iMark;

	TDbRecordId iRecord;

	CDbTable* iTable;

	};

/**

implementation class

@internalComponent

*/

class RDbTables		

	{

public:

	inline RDbTables();

	void Close();

//

	inline TBool IsEmpty() const;

	inline void Add( CDbTable& aTable );

	inline void Remove( CDbTable& aTable );

	CDbTable* Find( const TDesC& aTable );

	inline operator TSglQueBase&();

private:

	TSglQue<CDbTable> iRep;

	};

/**

@internalComponent

*/

enum TDbLockType { EDbReadLock = 0, EDbXReadLock, EDbWriteLock, EDbCompactLock, EDbRecoveryLock, EDbSchemaLock };

/**

implementation class

@internalComponent

*/

class RDbTransaction

	{

private:

	class CNotifier;

	friend class CNotifier;

public:

	inline RDbTransaction();

	inline void Open( CDbTableDatabase& aDatabase );

	void Close();

//

	inline const TDbGeneration& RollbackGeneration() const;

	inline CDbTableDatabase& Database();

//

	void BeginL( const CDbObject& aObject );

	void CommitL( const CDbObject& aObject );

	void Rollback( const CDbObject& aObject );

//

	void ReadPrepareL( const CDbObject& aObject );

	void ReadBegin( const CDbObject& aObject );

	void ReadRelease( const CDbObject& aObject );

//

	void DMLCheckL();

	void DMLPrepareL( const CDbObject& aObject );

	void DMLBegin();

	void DMLTouch();

	void DMLBeginLC();

	void DMLCommitL();

	void DMLRollback();

//

	void DDLPrepareL( const CDbObject& aObject );

	void DDLBegin();

	void DDLBeginLC();

	void DDLCommitL();

	void DDLRollback();

//

	void UtilityPrepareL( const CDbObject& aObject );

	void UtilityBegin( CDbDatabase::TUtility aType );

	void UtilityCommitL();

	void UtilityRollback();

//

	inline TBool IsLocked() const;

	inline void ReadyL() const;

	TBool InTransaction( const CDbObject& aObject );

//

	CDbNotifier* NotifierL();

#ifdef _ASSERTIONS

	void _Invariant() const;

#endif

private:

	typedef const CDbContext* THolder;

	struct TLock

		{

		THolder iHolder;

		TUint iState;

		};

	enum { ELockListGranularity = 4 };

	enum { ETransactionLock = 0x80000000 };

	enum { EState = 0x7f, EFailed = 0x80 };

	enum { EMaxLock = 255 };

private:

	inline TDbLockType LockState() const;

	void PrepareSLockL( const CDbObject& aObject, TUint aInitState );

	void PrepareXLockL( const CDbObject& aObject );

	void Unlock( RDbNotifier::TEvent aEvent );

	void Unlock( TLock& aLock );

	TLock* GetLock( const CDbObject& aObject );

	void Event( RDbNotifier::TEvent aEvent );

//

	void DoCommitL();

	void DoRollback();

	static void DMLAbandon( TAny* aPtr );

	static void DDLAbandon( TAny* aPtr );

private:

	CDbTableDatabase* iDatabase;

	TUint8 iAction;

	TUint8 iLockState;

	TUint8 iLockCount;

	TUint8 iMaxLock;

	TInt iUpdaters;

	TLock iPrimary;

	TLock* iSharers;

	TDbGeneration iRollback;

	CNotifier* iNotifier;

	};

/**

@internalComponent

*/

class CDbTableDatabase : public CBase

	{

private:

	class CIncremental;

	class CIncrementalDDL;

	class CCreateIndex;

	class CDropIndex;

	class CDropTable;

	class CAlterTable;

	class CUtility;

	class CInterface;

	class CSource;

//

	friend class RDbTransaction;

	friend class CInterface;

	friend class CSource;

	friend class CDbTable;

	friend class CIncremental;

public:

	/**

	@internalComponent

	*/

	class CStepper : public CBase

		{

	protected:

		CStepper() {}

	public:

		virtual TInt StepL( TInt aStep ) = 0;

		};

	/**

	@internalComponent

	*/

	class CMultiStepper : public CStepper

		{

	private:

		struct SStepper

			{

			CStepper* iStepper;

			TInt iStep;

			};

	public:

		~CMultiStepper();

		IMPORT_C static CMultiStepper* NewL( TInt aStepperCount );

		IMPORT_C void AddStepper( CStepper* aStepper, TInt aSteps );

		IMPORT_C TInt TotalSteps();

		TInt StepL( TInt aStep );

	private:

		inline CMultiStepper( TInt aStepperCount );

	private:

		SStepper* iStepper;

		SStepper* iEnd;

		SStepper iSteppers[1];		// one or more

		};

	/**

	@internalComponent

	*/

	class CBuildIndex : public CStepper

		{

	private:

		enum { ERecordsPerStep = 16 };

	public:

		IMPORT_C static CBuildIndex* NewL( CDbTableDatabase& aDatabase, const CDbTableDef& aTable, const CDbTableIndexDef& anIndex );

		~CBuildIndex();

		IMPORT_C static TInt Steps( TInt aCardinality );

		inline CDbRecordIndex& Index();

		IMPORT_C TInt StepsL();

		// from CStepper

		TInt StepL( TInt aStep );

	private:

		CBuildIndex();

	private:

		CDbTableSource* iSource;

		TDbPosition iNext;

		CDbRecordIndex* iIndex;

		};

protected:

	IMPORT_C CDbTableDatabase();

	IMPORT_C ~CDbTableDatabase();

public:

	inline RDbTransaction& Transaction();

//

	IMPORT_C CDbDatabase* InterfaceL();

	IMPORT_C CDbSource* SourceL();

//

	inline RDbTableSchema& Schema();

	IMPORT_C RDbTableSchema& SchemaL();

//

	CDbTableSource* TableSourceL( const TDesC& aTableName );

	void Release( const CDbTableDef& aDef );

// framework functions

	virtual CStepper* TableAlterL( CDbTableDef& aTable, const HDbColumnSet& aNewSet, TInt& aStep ) = 0;

	virtual CStepper* RecordDiscarderL( const CDbTableDef& aTable, TInt& aStep ) = 0;

	virtual CStepper* IndexDiscarderL( const CDbTableDef& aTable, const CDbTableIndexDef& anIndex, TInt& aStep ) = 0;

	IMPORT_C virtual CStepper* UtilityL( CDbDatabase::TUtility aType, TInt& aStep );

protected:

// framework

	IMPORT_C virtual TInt Property( CDbDatabase::TProperty aProperty );

private:

//framework

	virtual void AuthenticateL() = 0;

	IMPORT_C virtual void Idle();

	virtual void LoadSchemaL() = 0;

	virtual void SynchL( TDbLockType aLock ) = 0;

	virtual void Revert( TDbLockType aLock ) = 0;

	virtual CDbTable* TableL( const CDbTableDef& aDef ) = 0;

	virtual CDbTableDef* CreateTableL( const TDesC& aName, const CDbColSet& aColSet, const CDbKey* aPrimaryKey ) = 0;

	virtual CDbTableIndexDef* CreateIndexL( const CDbTableDef& aTable, const TDesC& aName, const CDbKey& aKey ) = 0;

	virtual void DestroyL() = 0;

//

	inline void Open();

	void Close();

	inline void AddTable( CDbTable& aTable );

	void RemoveTable( CDbTable& aTable );

//

	void CheckIdle();

	void FlushL( TDbLockType aLock );

	void Abandon( TDbLockType aLock );

	void Release();

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

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

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

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

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

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

	CDbCursor* PrepareTableL( const TDesC& aTable, RDbRowSet::TAccess anAccess );

// reserved virtual function space

	IMPORT_C virtual void Reserved_1();

	IMPORT_C virtual void Reserved_2();

private:

	TInt iRef;

	RDbCache iCache;

	RDbTransaction iTransaction;

	RDbTableSchema iSchema;

	RDbTables iTables;

	};

#include "D32TABLE.INL"

#endif