1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/utable/UT_DBS.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,568 @@
1.4 +// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "UT_STD.H"
1.20 +
1.21 +// Class CDbTableDatabase::CInterface
1.22 +
1.23 +//
1.24 +// ctor. Add the initial reference to the database engine
1.25 +//
1.26 +CDbTableDatabase::CInterface::CInterface(CDbTableDatabase& aDatabase)
1.27 + :iDatabase(aDatabase)
1.28 + {
1.29 + aDatabase.Open();
1.30 + }
1.31 +
1.32 +//
1.33 +// dtor. remove our reference from the database engine
1.34 +//
1.35 +CDbTableDatabase::CInterface::~CInterface()
1.36 + {
1.37 + if (Database().Transaction().InTransaction(*this))
1.38 + Rollback(); // release the lock if we have it
1.39 + Database().Close();
1.40 + }
1.41 +
1.42 +void CDbTableDatabase::CInterface::PrepareDDLL()
1.43 + {
1.44 + Database().Transaction().DDLPrepareL(*this);
1.45 + }
1.46 +
1.47 +//
1.48 +// destroy the database (database must be empty)
1.49 +//
1.50 +TInt CDbTableDatabase::CInterface::Destroy()
1.51 + {
1.52 + __ASSERT(Database().Schema().IsEmpty());
1.53 + TRAPD(r,Database().DestroyL());
1.54 + return r;
1.55 + }
1.56 +
1.57 +//
1.58 +// Initiate a transaction on the database
1.59 +//
1.60 +TInt CDbTableDatabase::CInterface::Begin()
1.61 + {
1.62 + TRAPD(r,Database().Transaction().BeginL(*this));
1.63 + return r;
1.64 + }
1.65 +
1.66 +//
1.67 +// Commit a transaction on the database
1.68 +//
1.69 +TInt CDbTableDatabase::CInterface::Commit()
1.70 + {
1.71 + TRAPD(r,Database().Transaction().CommitL(*this));
1.72 + return r;
1.73 + }
1.74 +
1.75 +//
1.76 +// Rollback a failed transaction on the database
1.77 +//
1.78 +void CDbTableDatabase::CInterface::Rollback()
1.79 + {
1.80 + Database().Transaction().Rollback(*this);
1.81 + }
1.82 +
1.83 +//
1.84 +// Report a requested property
1.85 +//
1.86 +TInt CDbTableDatabase::CInterface::Property(CDbDatabase::TProperty aProperty)
1.87 + {
1.88 + if (aProperty==EInTransaction)
1.89 + return Database().Transaction().InTransaction(*this) ? 1 : 0;
1.90 +//
1.91 + return Database().Property(aProperty);
1.92 + }
1.93 +
1.94 +void CDbTableDatabase::CInterface::CreateTableL(const TDesC& aName,const CDbColSet& aColSet,const CDbKey* aPrimaryKey)
1.95 + {
1.96 + PrepareDDLL();
1.97 + Database().DoCreateTableL(aName,aColSet,aPrimaryKey);
1.98 + }
1.99 +
1.100 +CDbCursor* CDbTableDatabase::CInterface::PrepareViewL(const TDbQuery& aQuery,const TDbWindow& aWindow,RDbRowSet::TAccess anAccess)
1.101 + {
1.102 + return Database().PrepareViewL(aQuery,aWindow,anAccess);
1.103 + }
1.104 +
1.105 +CDbCursor* CDbTableDatabase::CInterface::OpenTableL(const TDesC& aName,RDbRowSet::TAccess anAccess)
1.106 + {
1.107 + return Database().PrepareTableL(aName,anAccess);
1.108 + }
1.109 +
1.110 +CDbIncremental* CDbTableDatabase::CInterface::OpenDropTableL(const TDesC& aTable,TInt& aStep)
1.111 + {
1.112 + PrepareDDLL();
1.113 + return Database().OpenDropTableL(aTable,aStep);
1.114 + }
1.115 +
1.116 +CDbIncremental* CDbTableDatabase::CInterface::OpenAlterTableL(const TDesC& aTable,const CDbColSet& aNewDef,TInt& aStep)
1.117 + {
1.118 + PrepareDDLL();
1.119 + return Database().OpenAlterTableL(aTable,aNewDef,aStep);
1.120 + }
1.121 +
1.122 +CDbIncremental* CDbTableDatabase::CInterface::OpenCreateIndexL(const TDesC& aName,const TDesC& aTable,const CDbKey& aKey,TInt& aStep)
1.123 + {
1.124 + PrepareDDLL();
1.125 + return Database().OpenCreateIndexL(aName,aTable,aKey,aStep);
1.126 + }
1.127 +
1.128 +CDbIncremental* CDbTableDatabase::CInterface::OpenDropIndexL(const TDesC& aName,const TDesC& aTable,TInt& aStep)
1.129 + {
1.130 + PrepareDDLL();
1.131 + return Database().OpenDropIndexL(aName,aTable,aStep);
1.132 + }
1.133 +
1.134 +//
1.135 +// Create a database utility. Check the corresponding property to see if it is viable
1.136 +//
1.137 +CDbIncremental* CDbTableDatabase::CInterface::OpenUtilityL(CDbDatabase::TUtility aType,TInt& aStep)
1.138 + {
1.139 + if (!Property(TProperty(-aType)))
1.140 + { // nothing to do, or not capable
1.141 + aStep=0;
1.142 + return 0;
1.143 + }
1.144 + RDbTransaction& t=Database().Transaction();
1.145 + t.UtilityPrepareL(*this);
1.146 + if (aType==ERecover)
1.147 + Database().Release(); // must not have any tables open during recovery
1.148 + return CUtility::NewL(t,aType,aStep);
1.149 + }
1.150 +
1.151 +CDbIncremental* CDbTableDatabase::CInterface::OpenExecuteL(const TDesC& aSql,TDbTextComparison aComparison,TInt& aInit)
1.152 + {
1.153 + switch (Sql::Type(aSql))
1.154 + {
1.155 + default:
1.156 + __ASSERT(0);
1.157 + case Sql::ENone:
1.158 + __LEAVE(KErrArgument);
1.159 + case Sql::EDDL:
1.160 + {
1.161 + CDbIncremental* inc=Sql::ParseDDLStatementLC(aSql)->ExecuteL(*this,aComparison,aInit);
1.162 + CleanupStack::PopAndDestroy(); // statement
1.163 + return inc;
1.164 + }
1.165 + case Sql::EDML:
1.166 + {
1.167 + CSqlDMLStatement* statement=Sql::ParseDMLStatementLC(aSql);
1.168 + RDbTransaction& t=Database().Transaction();
1.169 + t.DMLCheckL(); // ensure we can open a cursor
1.170 + t.DMLPrepareL(*this);
1.171 + CDbIncremental* inc=statement->ExecuteL(Database(),aComparison,aInit);
1.172 + CleanupStack::PopAndDestroy(); // statement
1.173 + return inc;
1.174 + }
1.175 + }
1.176 + }
1.177 +
1.178 +//
1.179 +// Open a client-side notifier object
1.180 +//
1.181 +CDbNotifier* CDbTableDatabase::CInterface::OpenNotifierL()
1.182 + {
1.183 + return Database().Transaction().NotifierL();
1.184 + }
1.185 +
1.186 +//
1.187 +// list the tables on the database
1.188 +//
1.189 +void CDbTableDatabase::CInterface::TablesL(CDbTableNames& aNames)
1.190 + {
1.191 + TSglQueIterC<CDbTableDef> iter(Database().SchemaL());
1.192 + for (const CDbTableDef* def;(def=iter++)!=0;)
1.193 + aNames.AddL(def->Name());
1.194 + }
1.195 +
1.196 +//
1.197 +// build a column set for the table
1.198 +//
1.199 +void CDbTableDatabase::CInterface::ColumnsL(CDbColSet& aColSet,const TDesC& aName)
1.200 + {
1.201 + TDbCol col;
1.202 + const HDbColumnSet& set=Database().SchemaL().FindL(aName).Columns();
1.203 + HDbColumnSet::TIteratorC iter=set.Begin();
1.204 + const HDbColumnSet::TIteratorC end=set.End();
1.205 + do
1.206 + {
1.207 + iter->AsTDbCol(col);
1.208 + aColSet.AddL(col);
1.209 + } while (++iter<end);
1.210 + }
1.211 +
1.212 +//
1.213 +// List the indexes on a table
1.214 +//
1.215 +void CDbTableDatabase::CInterface::IndexesL(CDbIndexNames& aNames,const TDesC& aTable)
1.216 + {
1.217 + TSglQueIterC<CDbTableIndexDef> iter(Database().SchemaL().FindL(aTable).Indexes().AsQue());
1.218 + for (const CDbTableIndexDef* def;(def=iter++)!=0;)
1.219 + aNames.AddL(def->Name());
1.220 + }
1.221 +
1.222 +//
1.223 +// build a key for the index
1.224 +//
1.225 +void CDbTableDatabase::CInterface::KeysL(CDbKey& aKey,const TDesC& aName,const TDesC& aTable)
1.226 + {
1.227 + const CDbKey& key=Database().SchemaL().FindL(aTable).Indexes().FindL(aName).Key();
1.228 + TInt max=key.Count();
1.229 + for (TInt ii=0;ii<max;++ii)
1.230 + aKey.AddL(key[ii]);
1.231 + if (key.IsUnique())
1.232 + aKey.MakeUnique();
1.233 + if (key.IsPrimary())
1.234 + aKey.MakePrimary();
1.235 + aKey.SetComparison(key.Comparison());
1.236 + }
1.237 +
1.238 +// Class CDbTableDatabase::CSource
1.239 +
1.240 +//
1.241 +// ctor. Add a reference to the database engine
1.242 +//
1.243 +CDbTableDatabase::CSource::CSource(CDbTableDatabase& aDatabase)
1.244 + :iDatabase(aDatabase)
1.245 + {
1.246 + aDatabase.Open();
1.247 + }
1.248 +
1.249 +//
1.250 +// dtor. remove our reference from the database engine
1.251 +//
1.252 +CDbTableDatabase::CSource::~CSource()
1.253 + {
1.254 + Database().Close();
1.255 + }
1.256 +
1.257 +
1.258 +//SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method
1.259 +CDbDatabase* CDbTableDatabase::CSource::AuthenticateL()
1.260 + {
1.261 + Database().AuthenticateL();
1.262 + return Database().InterfaceL();
1.263 + }
1.264 +
1.265 +
1.266 +CDbNotifier* CDbTableDatabase::CSource::OpenNotifierL()
1.267 + {
1.268 + return Database().Transaction().NotifierL();
1.269 + }
1.270 +
1.271 +// Class CDbTableDatabase
1.272 +
1.273 +EXPORT_C CDbTableDatabase::CDbTableDatabase()
1.274 + {
1.275 + iCache.Open();
1.276 + iTransaction.Open(*this);
1.277 + }
1.278 +
1.279 +EXPORT_C CDbTableDatabase::~CDbTableDatabase()
1.280 + {
1.281 + __ASSERT(iRef==0);
1.282 + iTransaction.Close();
1.283 + iTables.Close();
1.284 + iSchema.Close();
1.285 + iCache.Close();
1.286 + }
1.287 +
1.288 +void CDbTableDatabase::Close()
1.289 + {
1.290 + __ASSERT(iRef>0);
1.291 + if (--iRef==0)
1.292 + delete this;
1.293 + }
1.294 +
1.295 +//
1.296 +// Construct the implementation interface for the database framework
1.297 +// On success, the interface takes an owning reference to this
1.298 +//
1.299 +EXPORT_C CDbDatabase* CDbTableDatabase::InterfaceL()
1.300 + {
1.301 + return new(ELeave) CInterface(*this);
1.302 + }
1.303 +
1.304 +//
1.305 +// Construct the implementation interface for the database framework
1.306 +// On success, the interface takes an owning reference to this
1.307 +//
1.308 +EXPORT_C CDbSource* CDbTableDatabase::SourceL()
1.309 + {
1.310 + return new(ELeave) CSource(*this);
1.311 + }
1.312 +
1.313 +//
1.314 +// Load the schema if required
1.315 +//
1.316 +EXPORT_C RDbTableSchema& CDbTableDatabase::SchemaL()
1.317 + {
1.318 + RDbTableSchema& schema=Schema();
1.319 + if (!schema.IsLoaded())
1.320 + {
1.321 + schema.Discard();
1.322 + LoadSchemaL();
1.323 + schema.Loaded();
1.324 + }
1.325 + return schema;
1.326 + }
1.327 +
1.328 +//
1.329 +// Find any tables which are now idle, and cache them
1.330 +// Caching such a table can result in *any* table being deleted
1.331 +// and so the iteration must restart every time an idle table is cached
1.332 +//
1.333 +void CDbTableDatabase::CheckIdle()
1.334 + {
1.335 + while (!iTables.IsEmpty())
1.336 + {
1.337 + for (TSglQueIter<CDbTable> iter(iTables);;)
1.338 + {
1.339 + CDbTable* table=iter++;
1.340 + if (table==0) // no more idle tables
1.341 + return;
1.342 + if (table->IsIdle())
1.343 + { // idle->cache transition can modify the collection
1.344 + table->Idle();
1.345 + break;
1.346 + }
1.347 + }
1.348 + }
1.349 + // If there are no tables left open, then the database can go idle
1.350 + Idle();
1.351 + }
1.352 +
1.353 +//
1.354 +// Does nothing by default
1.355 +//
1.356 +EXPORT_C void CDbTableDatabase::Idle()
1.357 + {
1.358 + }
1.359 +
1.360 +//
1.361 +// default implementation
1.362 +//
1.363 +EXPORT_C TInt CDbTableDatabase::Property(CDbDatabase::TProperty aProperty)
1.364 + {
1.365 + if (aProperty<0)
1.366 + return 0; // utilities are not available with table database
1.367 + __ASSERT(aProperty!=CDbDatabase::EInTransaction);
1.368 + return KErrNotSupported;
1.369 + }
1.370 +
1.371 +//
1.372 +// default implementation, should never be invoked
1.373 +//
1.374 +EXPORT_C CDbTableDatabase::CStepper* CDbTableDatabase::UtilityL(CDbDatabase::TUtility,TInt&)
1.375 + {
1.376 + __ASSERT(0);
1.377 + return 0;
1.378 + }
1.379 +
1.380 +void CDbTableDatabase::FlushL(TDbLockType aLock)
1.381 + {
1.382 + if (aLock>=EDbWriteLock)
1.383 + {
1.384 + TSglQueIter<CDbTable> iter(iTables);
1.385 + for (CDbTable* table;(table=iter++)!=0;)
1.386 + table->FlushL();
1.387 + }
1.388 + }
1.389 +
1.390 +void CDbTableDatabase::Abandon(TDbLockType aLock)
1.391 + {
1.392 + if (aLock>=EDbWriteLock)
1.393 + {
1.394 + TSglQueIter<CDbTable> iter(iTables);
1.395 + for (CDbTable* table;(table=iter++)!=0;)
1.396 + table->Abandon();
1.397 + }
1.398 + if (aLock==EDbSchemaLock)
1.399 + {
1.400 + Release(); // ensure no-one is using the old schema
1.401 + Schema().Discard();
1.402 + }
1.403 + }
1.404 +
1.405 +//
1.406 +// Discard a table if it is using this definition
1.407 +//
1.408 +void CDbTableDatabase::Release(const CDbTableDef& aDef)
1.409 + {
1.410 + TSglQueIter<CDbTable> iter(iTables);
1.411 + for (CDbTable* table;(table=iter++)!=0;)
1.412 + {
1.413 + if (&table->Def()==&aDef)
1.414 + {
1.415 + table->Release();
1.416 + break;
1.417 + }
1.418 + }
1.419 + }
1.420 +
1.421 +//
1.422 +// Discard all open tables as the schema has been modified or discarded
1.423 +//
1.424 +void CDbTableDatabase::Release()
1.425 + {
1.426 + TSglQueIter<CDbTable> iter(iTables);
1.427 + for (CDbTable* table;(table=iter++)!=0;)
1.428 + table->Release();
1.429 + }
1.430 +
1.431 +//
1.432 +// Remove a table from the open set
1.433 +//
1.434 +void CDbTableDatabase::RemoveTable(CDbTable& aTable)
1.435 + {
1.436 + iTables.Remove(aTable);
1.437 + if (!Transaction().IsLocked() && iTables.IsEmpty())
1.438 + Idle();
1.439 + }
1.440 +
1.441 +CDbTableSource* CDbTableDatabase::TableSourceL(const TDesC& aTableName)
1.442 + {
1.443 + CDbTableSource* rec=new(ELeave) CDbTableSource;
1.444 + CDbTable* table=iTables.Find(aTableName);
1.445 + if (table)
1.446 + table->Open(); // a new reference to it
1.447 + else
1.448 + {
1.449 + CleanupStack::PushL(rec);
1.450 + table=TableL(SchemaL().FindL(aTableName));
1.451 + CleanupStack::Pop(); // table source
1.452 + }
1.453 + rec->Construct(table);
1.454 + iCache.Flush(); // check-point for object cache membership
1.455 + return rec;
1.456 + }
1.457 +
1.458 +//
1.459 +// Prepare the data pipeline
1.460 +//
1.461 +CDbCursor* CDbTableDatabase::PrepareViewL(const TDbQuery& aQuery,const TDbWindow& aWindow,RDbRowSet::TAccess aAccess)
1.462 + {
1.463 + Transaction().DMLCheckL(); // ensure we can open a cursor
1.464 + CSqlQuery *query=Sql::ParseQueryLC(aQuery.Query());
1.465 + RDbAccessPlan plan(query,aQuery.Comparison());
1.466 + plan.BuildLC(*this,aAccess,aWindow);
1.467 + CDbTableCursor* cursor=CDbTableCursor::NewL(plan,aAccess);
1.468 + CleanupStack::Pop(); // the plan
1.469 + CleanupStack::PopAndDestroy(); // the query
1.470 + return cursor;
1.471 + }
1.472 +
1.473 +//
1.474 +// Prepare the data pipeline
1.475 +//
1.476 +CDbCursor* CDbTableDatabase::PrepareTableL(const TDesC& aTable,RDbRowSet::TAccess aAccess)
1.477 + {
1.478 + Transaction().DMLCheckL(); // ensure we can open a cursor
1.479 + RDbAccessPlan plan;
1.480 + plan.BuildLC(*this,aTable,aAccess);
1.481 + CDbTableCursor* cursor=CDbTableCursor::NewL(plan,aAccess);
1.482 + CleanupStack::Pop(); // the plan
1.483 + return cursor;
1.484 + }
1.485 +
1.486 +void CDbTableDatabase::DoCreateTableL(const TDesC& aName,const CDbColSet& aColSet,const CDbKey* aPrimaryKey)
1.487 + {
1.488 + if (SchemaL().Find(aName))
1.489 + __LEAVE(KErrAlreadyExists);
1.490 +// validate the colset set passed in
1.491 + Validate::NameL(aName);
1.492 + Validate::ColSetL(aColSet);
1.493 + Transaction().DDLBeginLC();
1.494 + iSchema.Add(CreateTableL(aName,aColSet,aPrimaryKey));
1.495 + Transaction().DDLCommitL();
1.496 + CleanupStack::Pop(); // rollback not required
1.497 + }
1.498 +
1.499 +//
1.500 +// Create index definition and prepare to build it
1.501 +//
1.502 +CDbTableDatabase::CIncremental* CDbTableDatabase::OpenCreateIndexL(const TDesC& aName,const TDesC& aTable,const CDbKey& aKey,TInt& aStep)
1.503 + {
1.504 + CDbTableDef& tDef=SchemaL().FindL(aTable);
1.505 + RDbIndexes& indexes=tDef.Indexes();
1.506 + if (indexes.Find(aName)!=NULL)
1.507 + __LEAVE(KErrAlreadyExists);
1.508 + if (indexes.Count()==KDbTableMaxIndexes)
1.509 + __LEAVE(KErrNotSupported);
1.510 + Validate::NameL(aName);
1.511 + Validate::KeyL(aKey,tDef.Columns());
1.512 + if (aKey.IsPrimary())
1.513 + __LEAVE(KErrArgument); // cannot create a primary index
1.514 +
1.515 + CCreateIndex* builder=CCreateIndex::NewLC(Transaction());
1.516 + CDbTableIndexDef* xDef=CreateIndexL(tDef,aName,aKey);
1.517 + tDef.Indexes().Add(xDef);
1.518 + Release(tDef); // release any table using the old schema
1.519 + aStep=builder->ConstructL(tDef,*xDef);
1.520 + CleanupStack::Pop(); // builder
1.521 + return builder;
1.522 + }
1.523 +
1.524 +//
1.525 +// Remove index from schema first, then remove index data
1.526 +//
1.527 +CDbTableDatabase::CIncremental* CDbTableDatabase::OpenDropIndexL(const TDesC& aName,const TDesC& aTable,TInt& aStep)
1.528 + {
1.529 + CDbTableDef& tDef=SchemaL().FindL(aTable);
1.530 + CDbTableIndexDef& xDef=tDef.Indexes().FindL(aName);
1.531 +//
1.532 + Release(tDef); // release any table using the old schema
1.533 + CDropIndex* drop=CDropIndex::NewL(Transaction(),tDef,&xDef,aStep);
1.534 + tDef.Indexes().Remove(&xDef);
1.535 + return drop;
1.536 + }
1.537 +
1.538 +CDbTableDatabase::CIncremental* CDbTableDatabase::OpenDropTableL(const TDesC& aTable,TInt& aStep)
1.539 + {
1.540 + CDbTableDef& tDef=SchemaL().FindL(aTable);
1.541 +//
1.542 + Release(tDef); // release the tables using the old schema
1.543 + CDropTable* drop=CDropTable::NewL(Transaction(),&tDef,aStep);
1.544 + iSchema.Remove(&tDef);
1.545 + return drop;
1.546 + }
1.547 +
1.548 +//
1.549 +// Create an incremental table altering object
1.550 +//
1.551 +CDbTableDatabase::CIncremental* CDbTableDatabase::OpenAlterTableL(const TDesC& aTable,const CDbColSet& aNewDef,TInt& aStep)
1.552 + {
1.553 + CDbTableDef& tDef=SchemaL().FindL(aTable);
1.554 + Validate::ColSetL(aNewDef);
1.555 + Release(tDef); // release the tables using the old schema
1.556 + return CAlterTable::NewL(Transaction(),tDef,aNewDef,aStep);
1.557 + }
1.558 +
1.559 +//
1.560 +// Reserved for future development
1.561 +//
1.562 +EXPORT_C void CDbTableDatabase::Reserved_1()
1.563 + {
1.564 + }
1.565 +
1.566 +//
1.567 +// Reserved for future development
1.568 +//
1.569 +EXPORT_C void CDbTableDatabase::Reserved_2()
1.570 + {
1.571 + }