Symaptic: os/persistentdata/persistentstorage/dbms/pcdbms/inc/D32TABLE.H@260cb5ec6c19

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #if !defined(__D32TABLE_H__)

    17 #define __D32TABLE_H__

    18 #if !defined(__D32DBAS_H__)

    19 #include "D32DBAS.H"

    20 #endif

    21 #if !defined(__D32REC_H__)

    22 #include "D32REC.H"

    23 #endif

    24 #if !defined(__D32CACHE_H__)

    25 #include "D32CACHE.H"

    26 #endif

    28 // classes defined in this file

    29 class TDbGenerationMark;

    30 class TDbColumnDef;

    31 class HDbColumnSet;

    32 class CDbTableIndexDef;

    33 class RDbIndexes;

    34 class RDbTableSchema;

    35 class CDbTableDef;

    36 class RDbTableRow;

    37 class CDbTable;

    38 class RDbTables;

    39 class RDbTransaction;

    40 class CDbTableDatabase;

    42 // classes also referenced

    43 class CDbTableSource;

    44 class CDbBlobCleanup;

    46 /**

    47 @internalComponent

    48 */

    49 const TInt KDbTableMaxIndexes = 32;

    51 /**

    52 @internalComponent

    53 */

    54 class CDbTableIndexDef : public CBase

    55 	{

    56 	friend class RDbIndexes;

    57 public:

    58 	IMPORT_C CDbTableIndexDef();

    59 	IMPORT_C ~CDbTableIndexDef();

    60 	IMPORT_C void ConstructL( const TDesC& aName );

    61 	inline const TDesC& Name() const;

    62 	inline const CDbKey& Key() const;

    63 	inline CDbKey& Key();

    64 private:

    65 	TSglQueLink iLink;

    66 	HBufC* iName;

    67 	CDbKey iKey;

    68 	};

    70 /**

    71 @internalComponent

    72 */

    73 class RDbIndexes

    74 	{

    75 	friend class CDbTableDef;

    76 public:

    77 	inline void Add( CDbTableIndexDef* aDef );

    78 	inline void Remove( CDbTableIndexDef* aDef );

    79 	inline const TSglQueBase& AsQue() const;

    80 	CDbTableIndexDef* Find( const TDesC& aName ) const;

    81 	CDbTableIndexDef& FindL( const TDesC& aName ) const;

    82 	IMPORT_C TInt Count() const;

    83 private:

    84 	inline RDbIndexes();

    85 	void Close();

    86 private:

    87 	TSglQue<CDbTableIndexDef> iRep;

    88 	};

    90 /**

    91 @internalComponent

    92 */

    93 class TDbColumnDef

    94 	{

    95 public:

    96 	IMPORT_C void SetL( const TDbCol& aCol );

    97 	IMPORT_C void SetL( const TDbColumnDef& aCol );

    98 	void AsTDbCol( TDbCol& aColumn ) const;

    99 	inline TDbColType Type() const;

   100 private:

   101 // don't allow copies

   102 	void operator=( const TDbColumnDef& );

   103 public:

   104 	// flags used by AlterTable

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

   106 public:

   107 	HBufC* iName;

   108 	TInt iMaxLength;

   109 	TUint8 iType;

   110 	TUint8 iAttributes;

   111 	TUint8 iFlags;

   112 	TUint8 iReserved;

   113 	};

   115 /**

   116 @internalComponent

   117 */

   118 class HDbColumnSet

   119 	{

   120 private:

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

   122 public:

   123 	typedef TDbColumnDef* TIterator;

   124 	typedef const TDbColumnDef* TIteratorC;

   125 public:

   126 	static HDbColumnSet* NewL( TInt aCount );

   127 	~HDbColumnSet();

   128 //

   129 	inline TIterator Begin();

   130 	void Complete();

   131 	IMPORT_C TInt Count() const;

   132 	inline TIteratorC Begin() const;

   133 	inline TIteratorC End() const;

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

   135 	IMPORT_C TIteratorC ColumnL( const TDesC& aColumn ) const;

   136 	inline TIterator ColumnL( const TDesC& aColumn );

   137 	IMPORT_C TDbColNo ColNoL( const TDesC& aColumn ) const;

   138 	inline TBool HasLongColumns() const;

   139 	inline TBool HasAutoIncrement() const;

   140 private:

   141 	HDbColumnSet( TInt aCount );

   142 	const TIteratorC* IndexL() const;

   143 private:

   144 	TUint iAttributes;

   145 	TIteratorC* iIndex;

   146 	const TDbColumnDef* const iEnd;

   147 	TDbColumnDef iColumns[1];		// at least one

   148 	};

   150 /**

   151 @internalComponent

   152 */

   153 class CDbTableDef : public CBase

   154 	{

   155 	friend class RDbTableSchema;

   156 public:

   157 	IMPORT_C ~CDbTableDef();

   158 	inline const TDesC& Name() const;

   159 	inline HDbColumnSet& Columns();

   160 	inline const HDbColumnSet& Columns() const;

   161 	inline RDbIndexes& Indexes();

   162 	inline const RDbIndexes& Indexes() const;

   163 	IMPORT_C virtual void Changed();

   164 //

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

   166 	inline TBool IsIndexed( const TDesC& aColumn ) const;

   167 //

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

   169 	void ExchangeColumnSet( HDbColumnSet* aSet );

   170 protected:

   171 	IMPORT_C CDbTableDef();

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

   173 private:

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

   175 private:

   176 	TSglQueLink iLink;

   177 	HBufC* iName;

   178 	HDbColumnSet* iColumns;

   179 	RDbIndexes iIndexes;

   180 	};

   182 /**

   183 @internalComponent

   184 */

   185 class RDbTableSchema

   186 	{

   187 	friend class CDbTableDatabase;

   188 public:

   189 	inline void Loaded();

   190 	inline operator TSglQueBase&();

   191 	inline void Add( CDbTableDef* aDef );

   192 //

   193 	inline TBool IsEmpty() const;

   194 	CDbTableDef* Find( const TDesC& aTable );

   195 	CDbTableDef& FindL( const TDesC& aTable );

   196 private:

   197 	inline RDbTableSchema();

   198 	void Close();

   199 //

   200 	inline TBool IsLoaded() const;

   201 	void Discard();

   202 	inline void Remove( CDbTableDef* aDef );

   203 private:

   204 	TSglQue<CDbTableDef> iRep;

   205 	TBool iLoaded;

   206 	};

   208 /**

   209 @internalComponent

   210 */

   211 typedef TUint TDbGeneration;

   213 /**

   214 @internalComponent

   215 */

   216 class TDbGenerationMark

   217 	{

   218 public:

   219 	inline void Construct( const TDbGeneration& aGeneration );

   220 	inline void Mark();

   221 	inline TBool Changed() const;

   222 private:

   223 	const TDbGeneration* iGeneration;

   224 	TDbGeneration iMark;

   225 	};

   227 /**

   228 @internalComponent

   229 */

   230 class CDbTable : public CBase

   231 	{

   232 	friend class RDbTables;

   233 public:

   234 	class TValid;

   235 	friend class TValid;

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

   237 protected:

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

   239 	IMPORT_C ~CDbTable();

   240 public:

   241 	void Open();

   242 	void Close();

   243 	void FlushL();

   244 	void Abandon();

   245 	void Release();

   246 	void Idle();

   247 //

   248 	inline TBool IsActive() const;

   249 	inline TBool IsIdle() const;

   250 	inline const CDbTableDef& Def() const;

   251 	inline CDbTableDatabase& Database();

   252 //

   253 	inline const TDbGeneration& Generation() const;

   254 	TBool ExistsL( TDbRecordId aRecordId );

   255 	void NewRowL( RDbRow& aRow );

   256 	void ReadRowL( RDbRow& aRow, TDbRecordId aRecordId );

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

   258 	void ReplaceRowL( RDbTableRow& aRow, TDbRecordId aRecordId );

   259 	void PrepareAppendL( const RDbTableRow& aRow );

   260 	TDbRecordId AppendRowL( const RDbTableRow& aRow );

   261 	void DeleteRowL( RDbTableRow& aRow, TDbRecordId aRecordId );

   262 	void DuplicateBlobsL( RDbRow& aRow );

   263 	IMPORT_C void DiscardBlobsL( RDbRow& aRow );

   264 //

   265 	IMPORT_C CDbRecordSpace& RecordsL();

   266 	IMPORT_C CDbRecordIndex& IndexL( const CDbTableIndexDef& anIndex );

   267 	IMPORT_C CDbBlobSpace* BlobsL();

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

   269 //

   270 	CDbRecordIter* IteratorL();

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

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

   273 	CDbRecordIter* IteratorL( const TDesC& aIndex );

   274 private:

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

   276 private:

   277 	inline void Discard();

   278 	void Disconnect();

   279 	inline TBool InUse() const;

   280 	inline RDbCache& Cache();

   281 //

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

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

   284 	void EnsureIndexesL();

   285 	void ValidateL( const RDbRow& aRow );

   286 	void CheckInliningL( RDbRow& aRow );

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

   288 //

   289 	virtual CDbRecordSpace* RecordSpaceL() = 0;

   290 	virtual CDbBlobSpace* BlobSpaceL() = 0;

   291 //

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

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

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

   295 private:

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

   297 private:

   298 	TSglQueLink iLink;

   299 	TInt iRef;

   300 	CDbTableDatabase* iDatabase;

   301 	const CDbTableDef* iDef;

   302 	TDbGeneration iGeneration;

   303 	CDbRecordSpace* iRecords;

   304 	CDbBlobSpace* iBlobs;

   305 	CDbRecordIndex* iIndexes[KDbTableMaxIndexes];

   306 	CDbRecordIndex** iIndexesEnd;

   307 	TUint32 iUpdateMap;

   308 	};

   310 /**

   311 @internalComponent

   312 */

   313 class RDbTableRow : public RDbRow

   314 	{

   315 public:

   316 	inline RDbTableRow();

   317 	void Open( CDbTable* aTable );

   318 	void Close();

   319 //

   320 	inline CDbTable& Table() const;

   321 	IMPORT_C void ReadL( TDbRecordId aRecordId );

   322 	void NewL( TDbRecordId aCopyRecord );

   323 	void PrepareAppendL();

   324 	TDbRecordId AppendL();

   325 	void PrepareReplaceL();

   326 	TDbRecordId ReplaceL();

   327 	void DeleteL( TDbRecordId aRecordId );

   328 private:

   329 	TDbGenerationMark iMark;

   330 	TDbRecordId iRecord;

   331 	CDbTable* iTable;

   332 	};

   334 /**

   335 implementation class

   336 @internalComponent

   337 */

   338 class RDbTables

   339 	{

   340 public:

   341 	inline RDbTables();

   342 	void Close();

   343 //

   344 	inline TBool IsEmpty() const;

   345 	inline void Add( CDbTable& aTable );

   346 	inline void Remove( CDbTable& aTable );

   347 	CDbTable* Find( const TDesC& aTable );

   348 	inline operator TSglQueBase&();

   349 private:

   350 	TSglQue<CDbTable> iRep;

   351 	};

   353 /**

   354 @internalComponent

   355 */

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

   358 /**

   359 implementation class

   360 @internalComponent

   361 */

   362 class RDbTransaction

   363 	{

   364 private:

   365 	class CNotifier;

   366 	friend class CNotifier;

   367 public:

   368 	inline RDbTransaction();

   369 	inline void Open( CDbTableDatabase& aDatabase );

   370 	void Close();

   371 //

   372 	inline const TDbGeneration& RollbackGeneration() const;

   373 	inline CDbTableDatabase& Database();

   374 //

   375 	void BeginL( const CDbObject& aObject );

   376 	void CommitL( const CDbObject& aObject );

   377 	void Rollback( const CDbObject& aObject );

   378 //

   379 	void ReadPrepareL( const CDbObject& aObject );

   380 	void ReadBegin( const CDbObject& aObject );

   381 	void ReadRelease( const CDbObject& aObject );

   382 //

   383 	void DMLCheckL();

   384 	void DMLPrepareL( const CDbObject& aObject );

   385 	void DMLBegin();

   386 	void DMLTouch();

   387 	void DMLBeginLC();

   388 	void DMLCommitL();

   389 	void DMLRollback();

   390 //

   391 	void DDLPrepareL( const CDbObject& aObject );

   392 	void DDLBegin();

   393 	void DDLBeginLC();

   394 	void DDLCommitL();

   395 	void DDLRollback();

   396 //

   397 	void UtilityPrepareL( const CDbObject& aObject );

   398 	void UtilityBegin( CDbDatabase::TUtility aType );

   399 	void UtilityCommitL();

   400 	void UtilityRollback();

   401 //

   402 	inline TBool IsLocked() const;

   403 	inline void ReadyL() const;

   404 	TBool InTransaction( const CDbObject& aObject );

   405 //

   406 	CDbNotifier* NotifierL();

   407 #ifdef _ASSERTIONS

   408 	void _Invariant() const;

   409 #endif

   410 private:

   411 	typedef const CDbContext* THolder;

   412 	struct TLock

   413 		{

   414 		THolder iHolder;

   415 		TUint iState;

   416 		};

   417 	enum { ELockListGranularity = 4 };

   418 	enum { ETransactionLock = 0x80000000 };

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

   420 	enum { EMaxLock = 255 };

   421 private:

   422 	inline TDbLockType LockState() const;

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

   424 	void PrepareXLockL( const CDbObject& aObject );

   425 	void Unlock( RDbNotifier::TEvent aEvent );

   426 	void Unlock( TLock& aLock );

   427 	TLock* GetLock( const CDbObject& aObject );

   428 	void Event( RDbNotifier::TEvent aEvent );

   429 //

   430 	void DoCommitL();

   431 	void DoRollback();

   432 	static void DMLAbandon( TAny* aPtr );

   433 	static void DDLAbandon( TAny* aPtr );

   434 private:

   435 	CDbTableDatabase* iDatabase;

   436 	TUint8 iAction;

   437 	TUint8 iLockState;

   438 	TUint8 iLockCount;

   439 	TUint8 iMaxLock;

   440 	TInt iUpdaters;

   441 	TLock iPrimary;

   442 	TLock* iSharers;

   443 	TDbGeneration iRollback;

   444 	CNotifier* iNotifier;

   445 	};

   447 /**

   448 @internalComponent

   449 */

   450 class CDbTableDatabase : public CBase

   451 	{

   452 private:

   453 	class CIncremental;

   454 	class CIncrementalDDL;

   455 	class CCreateIndex;

   456 	class CDropIndex;

   457 	class CDropTable;

   458 	class CAlterTable;

   459 	class CUtility;

   460 	class CInterface;

   461 	class CSource;

   462 //

   463 	friend class RDbTransaction;

   464 	friend class CInterface;

   465 	friend class CSource;

   466 	friend class CDbTable;

   467 	friend class CIncremental;

   468 public:

   469 	/**

   470 	@internalComponent

   471 	*/

   472 	class CStepper : public CBase

   473 		{

   474 	protected:

   475 		CStepper() {}

   476 	public:

   477 		virtual TInt StepL( TInt aStep ) = 0;

   478 		};

   480 	/**

   481 	@internalComponent

   482 	*/

   483 	class CMultiStepper : public CStepper

   484 		{

   485 	private:

   486 		struct SStepper

   487 			{

   488 			CStepper* iStepper;

   489 			TInt iStep;

   490 			};

   491 	public:

   492 		~CMultiStepper();

   493 		IMPORT_C static CMultiStepper* NewL( TInt aStepperCount );

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

   495 		IMPORT_C TInt TotalSteps();

   496 		TInt StepL( TInt aStep );

   497 	private:

   498 		inline CMultiStepper( TInt aStepperCount );

   499 	private:

   500 		SStepper* iStepper;

   501 		SStepper* iEnd;

   502 		SStepper iSteppers[1];		// one or more

   503 		};

   505 	/**

   506 	@internalComponent

   507 	*/

   508 	class CBuildIndex : public CStepper

   509 		{

   510 	private:

   511 		enum { ERecordsPerStep = 16 };

   512 	public:

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

   514 		~CBuildIndex();

   515 		IMPORT_C static TInt Steps( TInt aCardinality );

   516 		inline CDbRecordIndex& Index();

   517 		IMPORT_C TInt StepsL();

   518 		// from CStepper

   519 		TInt StepL( TInt aStep );

   520 	private:

   521 		CBuildIndex();

   522 	private:

   523 		CDbTableSource* iSource;

   524 		TDbPosition iNext;

   525 		CDbRecordIndex* iIndex;

   526 		};

   527 protected:

   528 	IMPORT_C CDbTableDatabase();

   529 	IMPORT_C ~CDbTableDatabase();

   530 public:

   531 	inline RDbTransaction& Transaction();

   532 //

   533 	IMPORT_C CDbDatabase* InterfaceL();

   534 	IMPORT_C CDbSource* SourceL();

   535 //

   536 	inline RDbTableSchema& Schema();

   537 	IMPORT_C RDbTableSchema& SchemaL();

   538 //

   539 	CDbTableSource* TableSourceL( const TDesC& aTableName );

   540 	void Release( const CDbTableDef& aDef );

   541 // framework functions

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

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

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

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

   546 protected:

   547 // framework

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

   549 private:

   550 //framework

   551 	virtual void AuthenticateL() = 0;

   552 	IMPORT_C virtual void Idle();

   553 	virtual void LoadSchemaL() = 0;

   554 	virtual void SynchL( TDbLockType aLock ) = 0;

   555 	virtual void Revert( TDbLockType aLock ) = 0;

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

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

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

   559 	virtual void DestroyL() = 0;

   560 //

   561 	inline void Open();

   562 	void Close();

   563 	inline void AddTable( CDbTable& aTable );

   564 	void RemoveTable( CDbTable& aTable );

   565 //

   566 	void CheckIdle();

   567 	void FlushL( TDbLockType aLock );

   568 	void Abandon( TDbLockType aLock );

   569 	void Release();

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

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

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

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

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

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

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

   578 // reserved virtual function space

   579 	IMPORT_C virtual void Reserved_1();

   580 	IMPORT_C virtual void Reserved_2();

   581 private:

   582 	TInt iRef;

   583 	RDbCache iCache;

   584 	RDbTransaction iTransaction;

   585 	RDbTableSchema iSchema;

   586 	RDbTables iTables;

   587 	};

   589 #include "D32TABLE.INL"

   590 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--