// 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 "UT_STD.H"

 // Class CDbTableDatabase::CInterface

 //

 // ctor. Add the initial reference to the database engine

 //

 CDbTableDatabase::CInterface::CInterface(CDbTableDatabase& aDatabase)

 	:iDatabase(aDatabase)

 	{

 	aDatabase.Open();

 	}

 //

 // dtor. remove our reference from the database engine

 //

 CDbTableDatabase::CInterface::~CInterface()

 	{

 	if (Database().Transaction().InTransaction(*this))

 		Rollback();			// release the lock if we have it

 	Database().Close();

 	}

 void CDbTableDatabase::CInterface::PrepareDDLL()

 	{

 	Database().Transaction().DDLPrepareL(*this);

 	}

 //

 // destroy the database (database must be empty)

 //

 TInt CDbTableDatabase::CInterface::Destroy()

 	{

 	__ASSERT(Database().Schema().IsEmpty());

 	TRAPD(r,Database().DestroyL());

 	return r;

 	}

 //

 // Initiate a transaction on the database

 //

 TInt CDbTableDatabase::CInterface::Begin()

 	{

 	TRAPD(r,Database().Transaction().BeginL(*this));

 	return r;

 	}

 //

 // Commit a transaction on the database

 //

 TInt CDbTableDatabase::CInterface::Commit()

 	{

 	TRAPD(r,Database().Transaction().CommitL(*this));

 	return r;

 	}

 //

 // Rollback a failed transaction on the database

 //

 void CDbTableDatabase::CInterface::Rollback()

 	{

 	Database().Transaction().Rollback(*this);

 	}

 //

 // Report a requested property

 //

 TInt CDbTableDatabase::CInterface::Property(CDbDatabase::TProperty aProperty)

 	{

 	if (aProperty==EInTransaction)

 		return Database().Transaction().InTransaction(*this) ? 1 : 0;

 //

 	return Database().Property(aProperty);

 	}

 void CDbTableDatabase::CInterface::CreateTableL(const TDesC& aName,const CDbColSet& aColSet,const CDbKey* aPrimaryKey)

 	{

 	PrepareDDLL();

 	Database().DoCreateTableL(aName,aColSet,aPrimaryKey);

 	}

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

 	{

 	return Database().PrepareViewL(aQuery,aWindow,anAccess);

 	}

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

 	{

 	return Database().PrepareTableL(aName,anAccess);

 	}

 CDbIncremental* CDbTableDatabase::CInterface::OpenDropTableL(const TDesC& aTable,TInt& aStep)

 	{

 	PrepareDDLL();

 	return Database().OpenDropTableL(aTable,aStep);

 	}

 CDbIncremental* CDbTableDatabase::CInterface::OpenAlterTableL(const TDesC& aTable,const CDbColSet& aNewDef,TInt& aStep)

 	{

 	PrepareDDLL();

 	return Database().OpenAlterTableL(aTable,aNewDef,aStep);

 	}

 CDbIncremental* CDbTableDatabase::CInterface::OpenCreateIndexL(const TDesC& aName,const TDesC& aTable,const CDbKey& aKey,TInt& aStep)

 	{

 	PrepareDDLL();

 	return Database().OpenCreateIndexL(aName,aTable,aKey,aStep);

 	}

 CDbIncremental* CDbTableDatabase::CInterface::OpenDropIndexL(const TDesC& aName,const TDesC& aTable,TInt& aStep)

 	{

 	PrepareDDLL();

 	return Database().OpenDropIndexL(aName,aTable,aStep);

 	}

 //

 // Create a database utility. Check the corresponding property to see if it is viable

 //

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

 	{

 	if (!Property(TProperty(-aType)))

 		{	// nothing to do, or not capable

 		aStep=0;

 		return 0;

 		}

 	RDbTransaction& t=Database().Transaction();

 	t.UtilityPrepareL(*this);

 	if (aType==ERecover)

 		Database().Release();		// must not have any tables open during recovery

 	return CUtility::NewL(t,aType,aStep);

 	}

 CDbIncremental* CDbTableDatabase::CInterface::OpenExecuteL(const TDesC& aSql,TDbTextComparison aComparison,TInt& aInit)

 	{

 	switch (Sql::Type(aSql))

 		{

 	default:

 		__ASSERT(0);

 	case Sql::ENone:

 		__LEAVE(KErrArgument);

 	case Sql::EDDL:

 		{

 		CDbIncremental* inc=Sql::ParseDDLStatementLC(aSql)->ExecuteL(*this,aComparison,aInit);

 		CleanupStack::PopAndDestroy();		// statement

 		return inc;

 		}

 	case Sql::EDML:

 		{

 		CSqlDMLStatement* statement=Sql::ParseDMLStatementLC(aSql);

 		RDbTransaction& t=Database().Transaction();

 		t.DMLCheckL();			// ensure we can open a cursor

 		t.DMLPrepareL(*this);

 		CDbIncremental* inc=statement->ExecuteL(Database(),aComparison,aInit);

 		CleanupStack::PopAndDestroy();		// statement

 		return inc;

 		}

 		}

 	}

 //

 // Open a client-side notifier object

 //

 CDbNotifier* CDbTableDatabase::CInterface::OpenNotifierL()

 	{

 	return Database().Transaction().NotifierL();

 	}

 //

 // list the tables on the database

 //

 void CDbTableDatabase::CInterface::TablesL(CDbTableNames& aNames)

 	{

 	TSglQueIterC<CDbTableDef> iter(Database().SchemaL());

 	for (const CDbTableDef* def;(def=iter++)!=0;)

 		aNames.AddL(def->Name());

 	}

 //

 // build a column set for the table

 //

 void CDbTableDatabase::CInterface::ColumnsL(CDbColSet& aColSet,const TDesC& aName)

 	{

 	TDbCol col;

 	const HDbColumnSet& set=Database().SchemaL().FindL(aName).Columns();

 	HDbColumnSet::TIteratorC iter=set.Begin();

 	const HDbColumnSet::TIteratorC end=set.End();

 	do

 		{

 		iter->AsTDbCol(col);

 		aColSet.AddL(col);

 		} while (++iter<end);

 	}

 //

 // List the indexes on a table

 //

 void CDbTableDatabase::CInterface::IndexesL(CDbIndexNames& aNames,const TDesC& aTable)

 	{

 	TSglQueIterC<CDbTableIndexDef> iter(Database().SchemaL().FindL(aTable).Indexes().AsQue());

 	for (const CDbTableIndexDef* def;(def=iter++)!=0;)

 		aNames.AddL(def->Name());

 	}

 //

 // build a key for the index

 //

 void CDbTableDatabase::CInterface::KeysL(CDbKey& aKey,const TDesC& aName,const TDesC& aTable)

 	{

 	const CDbKey& key=Database().SchemaL().FindL(aTable).Indexes().FindL(aName).Key();

 	TInt max=key.Count();

 	for (TInt ii=0;ii<max;++ii)

 		aKey.AddL(key[ii]);

 	if (key.IsUnique())

 		aKey.MakeUnique();

 	if (key.IsPrimary())

 		aKey.MakePrimary();

 	aKey.SetComparison(key.Comparison());

 	}

 // Class CDbTableDatabase::CSource

 //

 // ctor. Add a reference to the database engine

 //

 CDbTableDatabase::CSource::CSource(CDbTableDatabase& aDatabase)

 	:iDatabase(aDatabase)

 	{

 	aDatabase.Open();

 	}

 //

 // dtor. remove our reference from the database engine

 //

 CDbTableDatabase::CSource::~CSource()

 	{

 	Database().Close();

 	}

 //SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method

 CDbDatabase* CDbTableDatabase::CSource::AuthenticateL()

 	{

 	Database().AuthenticateL();

 	return Database().InterfaceL();

 	}

 CDbNotifier* CDbTableDatabase::CSource::OpenNotifierL()

 	{

 	return Database().Transaction().NotifierL();

 	}

 // Class CDbTableDatabase

 EXPORT_C CDbTableDatabase::CDbTableDatabase()

 	{

 	iCache.Open();

 	iTransaction.Open(*this);

 	}

 EXPORT_C CDbTableDatabase::~CDbTableDatabase()

 	{

 	__ASSERT(iRef==0);

 	iTransaction.Close();

 	iTables.Close();

 	iSchema.Close();

 	iCache.Close();

 	}

 void CDbTableDatabase::Close()

 	{

 	__ASSERT(iRef>0);

 	if (--iRef==0)

 		delete this;

 	}

 //

 // Construct the implementation interface for the database framework

 // On success, the interface takes an owning reference to this

 //

 EXPORT_C CDbDatabase* CDbTableDatabase::InterfaceL()

 	{

 	return new(ELeave) CInterface(*this);

 	}

 //

 // Construct the implementation interface for the database framework

 // On success, the interface takes an owning reference to this

 //

 EXPORT_C CDbSource* CDbTableDatabase::SourceL()

 	{

 	return new(ELeave) CSource(*this);

 	}

 //

 // Load the schema if required

 //

 EXPORT_C RDbTableSchema& CDbTableDatabase::SchemaL()

 	{

 	RDbTableSchema& schema=Schema();

 	if (!schema.IsLoaded())

 		{

 		schema.Discard();

 		LoadSchemaL();

 		schema.Loaded();

 		}

 	return schema;

 	}

 //

 // Find any tables which are now idle, and cache them

 // Caching such a table can result in *any* table being deleted

 //  and so the iteration must restart every time an idle table is cached

 //

 void CDbTableDatabase::CheckIdle()

 	{

 	while (!iTables.IsEmpty())

 		{

 		for (TSglQueIter<CDbTable> iter(iTables);;)

 			{

 			CDbTable* table=iter++;

 			if (table==0)		// no more idle tables

 				return;

 			if (table->IsIdle())

 				{	// idle->cache transition can modify the collection

 				table->Idle();

 				break;

 				}

 			}

 		}

 	// If there are no tables left open, then the database can go idle

 	Idle();

 	}

 //

 // Does nothing by default

 //

 EXPORT_C void CDbTableDatabase::Idle()

 	{

     }

 //

 // default implementation

 //

 EXPORT_C TInt CDbTableDatabase::Property(CDbDatabase::TProperty aProperty)

 	{

 	if (aProperty<0)

 		return 0;		// utilities are not available with table database

 	__ASSERT(aProperty!=CDbDatabase::EInTransaction);

 	return KErrNotSupported;

 	}

 //

 // default implementation, should never be invoked

 //

 EXPORT_C CDbTableDatabase::CStepper* CDbTableDatabase::UtilityL(CDbDatabase::TUtility,TInt&)

 	{

 	__ASSERT(0);

 	return 0;

 	}

 void CDbTableDatabase::FlushL(TDbLockType aLock)

 	{

 	if (aLock>=EDbWriteLock)

 		{

 		TSglQueIter<CDbTable> iter(iTables);

 		for (CDbTable* table;(table=iter++)!=0;)

 			table->FlushL();

 		}

 	}

 void CDbTableDatabase::Abandon(TDbLockType aLock)

 	{

 	if (aLock>=EDbWriteLock)

 		{

 		TSglQueIter<CDbTable> iter(iTables);

 		for (CDbTable* table;(table=iter++)!=0;)

 			table->Abandon();

 		}

 	if (aLock==EDbSchemaLock)

 		{

 		Release();			// ensure no-one is using the old schema

 		Schema().Discard();

 		}

 	}

 //

 // Discard a table if it is using this definition

 //

 void CDbTableDatabase::Release(const CDbTableDef& aDef)

 	{

 	TSglQueIter<CDbTable> iter(iTables);

 	for (CDbTable* table;(table=iter++)!=0;)

 		{

 		if (&table->Def()==&aDef)

 			{

 			table->Release();

 			break;

 			}

 		}

 	}

 //

 // Discard all open tables as the schema has been modified or discarded

 //

 void CDbTableDatabase::Release()

 	{

 	TSglQueIter<CDbTable> iter(iTables);

 	for (CDbTable* table;(table=iter++)!=0;)

 		table->Release();

 	}

 //

 // Remove a table from the open set

 //

 void CDbTableDatabase::RemoveTable(CDbTable& aTable)

 	{

 	iTables.Remove(aTable);

 	if (!Transaction().IsLocked() && iTables.IsEmpty())

 		Idle();

 	}

 CDbTableSource* CDbTableDatabase::TableSourceL(const TDesC& aTableName)

 	{

 	CDbTableSource* rec=new(ELeave) CDbTableSource;

 	CDbTable* table=iTables.Find(aTableName);

 	if (table)

 		table->Open();		// a new reference to it

 	else

 		{

 		CleanupStack::PushL(rec);

 		table=TableL(SchemaL().FindL(aTableName));

 		CleanupStack::Pop();	// table source

 		}

 	rec->Construct(table);

 	iCache.Flush();			// check-point for object cache membership

 	return rec;

 	}

 //

 // Prepare the data pipeline

 //

 CDbCursor* CDbTableDatabase::PrepareViewL(const TDbQuery& aQuery,const TDbWindow& aWindow,RDbRowSet::TAccess aAccess)

 	{

 	Transaction().DMLCheckL();	// ensure we can open a cursor

 	CSqlQuery *query=Sql::ParseQueryLC(aQuery.Query());

 	RDbAccessPlan plan(query,aQuery.Comparison());

 	plan.BuildLC(*this,aAccess,aWindow);

 	CDbTableCursor* cursor=CDbTableCursor::NewL(plan,aAccess);

 	CleanupStack::Pop();			// the plan

 	CleanupStack::PopAndDestroy();	// the query

 	return cursor;

 	}

 //

 // Prepare the data pipeline

 //

 CDbCursor* CDbTableDatabase::PrepareTableL(const TDesC& aTable,RDbRowSet::TAccess aAccess)

 	{

 	Transaction().DMLCheckL();	// ensure we can open a cursor

 	RDbAccessPlan plan;

 	plan.BuildLC(*this,aTable,aAccess);

 	CDbTableCursor* cursor=CDbTableCursor::NewL(plan,aAccess);

 	CleanupStack::Pop();			// the plan

 	return cursor;

 	}

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

 	{

 	if (SchemaL().Find(aName))

 		__LEAVE(KErrAlreadyExists);

 // validate the colset set passed in

 	Validate::NameL(aName);

 	Validate::ColSetL(aColSet);

 	Transaction().DDLBeginLC();

 	iSchema.Add(CreateTableL(aName,aColSet,aPrimaryKey));

 	Transaction().DDLCommitL();

 	CleanupStack::Pop();		// rollback not required

 	}

 //

 // Create index definition and prepare to build it

 //

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

 	{

 	CDbTableDef& tDef=SchemaL().FindL(aTable);

 	RDbIndexes& indexes=tDef.Indexes();

 	if (indexes.Find(aName)!=NULL)

 		__LEAVE(KErrAlreadyExists);

 	if (indexes.Count()==KDbTableMaxIndexes)

 		__LEAVE(KErrNotSupported);

 	Validate::NameL(aName);

 	Validate::KeyL(aKey,tDef.Columns());

 	if (aKey.IsPrimary())

 		__LEAVE(KErrArgument);	// cannot create a primary index

 	CCreateIndex* builder=CCreateIndex::NewLC(Transaction());

 	CDbTableIndexDef* xDef=CreateIndexL(tDef,aName,aKey);

 	tDef.Indexes().Add(xDef);

 	Release(tDef);				// release any table using the old schema

 	aStep=builder->ConstructL(tDef,*xDef);

 	CleanupStack::Pop();	// builder

 	return builder;

 	}

 //

 // Remove index from schema first, then remove index data

 //

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

 	{

 	CDbTableDef& tDef=SchemaL().FindL(aTable);

 	CDbTableIndexDef& xDef=tDef.Indexes().FindL(aName);

 //

 	Release(tDef);				// release any table using the old schema

 	CDropIndex* drop=CDropIndex::NewL(Transaction(),tDef,&xDef,aStep);

 	tDef.Indexes().Remove(&xDef);

 	return drop;

 	}

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

 	{

 	CDbTableDef& tDef=SchemaL().FindL(aTable);

 //

 	Release(tDef);				// release the tables using the old schema

 	CDropTable* drop=CDropTable::NewL(Transaction(),&tDef,aStep);

 	iSchema.Remove(&tDef);

 	return drop;

 	}

 //

 // Create an incremental table altering object

 //

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

 	{

 	CDbTableDef& tDef=SchemaL().FindL(aTable);

 	Validate::ColSetL(aNewDef);

 	Release(tDef);				// release the tables using the old schema

 	return CAlterTable::NewL(Transaction(),tDef,aNewDef,aStep);

 	}

 //

 // Reserved for future development

 //

 EXPORT_C void CDbTableDatabase::Reserved_1()

 	{

     }

 //

 // Reserved for future development

 //

 EXPORT_C void CDbTableDatabase::Reserved_2()

 	{

     }