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

// Class CDbStoreDatabase::CCompactor

NONSHARABLE_CLASS(CDbStoreDatabase::CCompactor) : public CDbStoreDatabase::CStepper

	{

public:

	static CCompactor* NewL(CDbDatabase::TUtility aType, CStreamStore& aStore,

                            TInt& aReclaim, TInt& aStep);

	~CCompactor();

private:

	inline CCompactor(TInt& aReclaim);

// from CStepper

	TInt StepL(TInt aStep);

private:

	RStoreReclaim iReclaimer;

	TInt& iReclaim;

	};

inline CDbStoreDatabase::CCompactor::CCompactor(TInt& aReclaim)

	:iReclaim(aReclaim)

	{

	}

CDbStoreDatabase::CCompactor* CDbStoreDatabase::CCompactor::NewL(CDbDatabase::TUtility aType,

																 CStreamStore& aStore,

																 TInt& aReclaim,TInt& aStep)

	{

	CCompactor* self=new(ELeave) CCompactor(aReclaim);

	CleanupStack::PushL(self);

	if (aType==CDbDatabase::ECompact)

		self->iReclaimer.CompactL(aStore,aStep);

	else

		self->iReclaimer.OpenL(aStore,aStep);

	CleanupStack::Pop();

	return self;

	}

CDbStoreDatabase::CCompactor::~CCompactor()

	{

	iReclaimer.Close();

	}

//

// Single step the compactor

// We cannot deal with the "in use" scenario as we could end up locking out forever

// that has to be left to clients using the RDbIncremental interface

//

TInt CDbStoreDatabase::CCompactor::StepL(TInt aStep)

	{

	iReclaimer.NextL(aStep);

	if (aStep==0)

		{

		iReclaim=iReclaimer.Available();

		iReclaimer.Close();

		}

	return aStep;

	}

// Class CDbStoreDatabase

EXPORT_C CDbStoreDatabase::CDbStoreDatabase()

	:iReclaim(KErrGeneral)

	{

	}

//

// Create a StoreDatabase object. This type shares the store

//

CDbStoreDatabase* CDbStoreDatabase::NewLC(CStreamStore* aStore)

	{

	__ASSERT(aStore);

	CDbStoreDatabase* self=new(ELeave) CDbStoreDatabase;

	CleanupStack::PushL(self);

	self->iStore=aStore;

	self->iSharedStore=1;

	return self;

	}

//SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method.

CDbDatabase* CDbStoreDatabase::CreateL(CStreamStore* aStore,TStreamId& aStreamId)

	{

	CDbStoreDatabase* self=NewLC(aStore);

	aStreamId=self->ConstructL();

	CDbDatabase* db=self->InterfaceL();

	CleanupStack::Pop();			// self

	return db;

	}

// SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method.

// Phase 2 construction for creating a new database

// Initialise a new database object, creating the required persistent structure

//

EXPORT_C TStreamId CDbStoreDatabase::ConstructL()

	{

	__ASSERT(iStore);	// this must have been provided by now

	iVersion=TUint8(EDbStoreVersion2);

	InitPagePoolL();

	iPagePool->Create(Store());

	iTokenId=Store().ExtendL();

	ReplaceTokenL(0);

	iSchemaId=Store().ExtendL();

	Schema().Loaded();

	ReplaceSchemaL();

	return iSchemaId;

	}

// SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method.

// Open phase #2: Authenticate the client

//

EXPORT_C void CDbStoreDatabase::AuthenticateL()

	{

	if (!iPagePool)

		{

		// first client to open the database, so complete initialisation now

		InitPagePoolL();

		SchemaL();

		}

	}

// SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method.

void CDbStoreDatabase::InitPagePoolL()

	{

	iPagePool = new(ELeave) RStorePagePool;

	}

CDbSource* CDbStoreDatabase::OpenL(CStreamStore* aStore,TStreamId aStreamId)

	{

	CDbStoreDatabase* self=NewLC(aStore);

	self->RestoreL(aStreamId);

	CDbSource* src=self->SourceL();

	CleanupStack::Pop();			// self

	return src;

	}

//

// Phase 2 construction for opening a database

// Client must still authenticate before it can be used

//

EXPORT_C void CDbStoreDatabase::RestoreL(TStreamId aStreamId)

	{

	__ASSERT(iStore);	// this must have been provided by now

	iSchemaId=aStreamId;

// read the databse header for encryption information

	RStoreReadStream strm;

	strm.OpenLC(Store(),aStreamId);

	ReadHeaderL(strm);

	CleanupStack::PopAndDestroy();	// strm

	}

//

// Load the root stream header (up to the security key)

//

void CDbStoreDatabase::ReadHeaderL(RReadStream& aStream)

	{

	TUid uid;

	aStream>>uid;

	if (uid!=KDbmsStoreDatabase)

		__LEAVE(KErrArgument);

	aStream>>iVersion;

	switch (iVersion)

		{

	case EDbStoreCompressed:

		aStream>>CompressionL();

		break;

	case EDbStoreVersion2:

		break;

	default:

		__LEAVE(KErrNotSupported);

		break;

		}

	}

CDbStoreCompression& CDbStoreDatabase::CompressionL()

	{

	CDbStoreCompression* c=iCompression;

	if (!c)

		iFilter=iCompression=c=CDbStoreCompression::NewL();

	return *c;

	}

EXPORT_C CDbStoreDatabase::~CDbStoreDatabase()

	{

	if (iPageCache)

		{

		iPagePool->Release();

		delete iPageCache;

		}

	delete iClusterCache;

	delete iPagePool;

	delete iCompression;

	if (!iSharedStore)

		delete iStore;

	}

//

// Validate the column set first

//

EXPORT_C CDbTableDef* CDbStoreDatabase::CreateTableL(const TDesC& aName,const CDbColSet& aColSet,const CDbKey* aPrimaryKey)

	{

	if (aPrimaryKey)

		__LEAVE(KErrNotSupported);	// Store database does not support primary keys

	CDbStoreDef* def=CDbStoreDef::NewLC(aName,aColSet);

	def->SetTokenId(CDbStoreRecords::CreateL(ClusterCacheL()));

	CleanupStack::Pop();

	return def;

	}

EXPORT_C CDbTableIndexDef* CDbStoreDatabase::CreateIndexL(const CDbTableDef& aTable,const TDesC& aName,const CDbKey& aKey)

	{

	CDbStoreIndexDef* def=CDbStoreIndexDef::NewLC(aName,aKey,aTable.Columns());

	def->SetTokenId(CDbStoreIndex::CreateL(*this,*def));

	CleanupStack::Pop();			// IndexDef

	return def;

	}

//

// Destroy the entire database...

//

EXPORT_C void CDbStoreDatabase::DestroyL()

	{

	iPagePool->Discard();

	iPagePool->ReclaimAllL();	// reclaim all page pool space

	iStore->DeleteL(iSchemaId);

	iStore->DeleteL(iTokenId);

	iStore->CommitL();

	}

EXPORT_C CDbTable* CDbStoreDatabase::TableL(const CDbTableDef& aDef)

	{

	return new(ELeave) CDbStoreTable(*this,aDef);

	}

//

// load the schema for the database

//

EXPORT_C void CDbStoreDatabase::LoadSchemaL()

	{

	RDbStoreReadStream strm(*this);

	strm.OpenLC(Store(),iSchemaId);

	ReadHeaderL(strm);

	strm.FilterL(strm.EMixed,iSchemaId.Value());

	strm>>iTokenId;

	RDbTableSchema& schema=Schema();

	TCardinality tables;

	strm>>tables;

	for (TInt ii=tables;ii>0;--ii)

		schema.Add(CDbStoreDef::NewL(strm));

	CleanupStack::PopAndDestroy();

	strm.OpenLC(Store(),iTokenId);

	strm>>iFlags>>iPoolToken;

	iPagePool->Open(Store(),iPoolToken);

	CleanupStack::PopAndDestroy();

	}

//

// Re-write the schema stream

//

void CDbStoreDatabase::ReplaceSchemaL()

	{

	RDbStoreWriteStream out(*this);

	out.ReplaceLC(Store(),iSchemaId);

	out<<KDbmsStoreDatabase<<iVersion;

	switch (iVersion)

		{

	case EDbStoreCompressed:

		__ASSERT(iCompression);

		out<<*iCompression;

		break;

	case EDbStoreVersion2:

		break;

	default:

		__ASSERT(0);

		}

	out.FilterL(out.EMixed,iSchemaId.Value());

	out<<iTokenId;

	TSglQueIterC<CDbStoreDef> iter(Schema());

	TInt count=0;

	while (iter++)

		++count;

	out<<TCardinality(count);

	iter.SetToFirst();

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

		out<<*def;

	out.CommitL();

	CleanupStack::PopAndDestroy();

	}

//

// Re-write the token stream, removing the mark

//

void CDbStoreDatabase::ReplaceTokenL(TUint aFlags)

	{

	RStoreWriteStream out;

	out.ReplaceLC(Store(),iTokenId);

	out<<TUint8(aFlags&EDamaged)<<iPagePool->Token();

	out.CommitL();

	CleanupStack::PopAndDestroy();

	}

//

// Return some database property

//

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

	{

	switch (aProperty)

		{

	case CDbDatabase::EIsDamaged:

		return iFlags&EDamaged ? 1 : 0;

	case CDbDatabase::ECompactable:

		return 1;

	default:

		return CDbTableDatabase::Property(aProperty);

		}

	}

//

// mark the database as dirty

//

void CDbStoreDatabase::MarkL()

	{

	if (!(iFlags&EModified))

		{

		RStoreWriteStream out;

		out.OpenLC(Store(),iTokenId);

		out.WriteUint8L(EDamaged);		// mark as dirty

		iPoolToken.Touch();

		out<<iPoolToken;

		out.CommitL();

		CleanupStack::PopAndDestroy();

		iFlags|=EModified;

		}

	}

//

// Reset all cache buffers

//

EXPORT_C void CDbStoreDatabase::Idle()

	{

	if (iPageCache)

		{

		iPagePool->Purge();

		delete iPageCache;

		iPageCache=NULL;

		}

	if (iClusterCache)

		{

		delete iClusterCache;

		iClusterCache=NULL;

		}

	}

//

// Commit the store, and when all is well, clear the token

//

void CDbStoreDatabase::SynchStoreL(TDbLockType aLock)

	{

	if (iPageCache)

		iPagePool->FlushL();

	TUint newflags=iFlags&~EModified;

	if (aLock==EDbRecoveryLock)

		newflags&=~EDamaged;

	if (aLock==EDbRecoveryLock || iFlags&EModified)

		ReplaceTokenL(newflags);

	if (aLock>=EDbWriteLock || iSharedStore)

		{

		iStore->CommitL();

		iFlags=TUint8(newflags);

		iPoolToken=iPagePool->Token();

		}

	}

//

// An index has been successfully recovered, commit it

//

void CDbStoreDatabase::IndexRecoveredL()

	{

	SynchStoreL(EDbSchemaLock);

	}

//

// Ensure all data is in the store

//

EXPORT_C void CDbStoreDatabase::SynchL(TDbLockType aLock)

	{

	if (aLock==EDbSchemaLock)

		ReplaceSchemaL();

	if (iClusterCache)

		iClusterCache->FlushL();

	SynchStoreL(aLock);

	}

//

// Unwind the store, throw out changes, etc

//

EXPORT_C void CDbStoreDatabase::Revert(TDbLockType aLock)

	{

	if (aLock>=EDbWriteLock)

		{

		if (iClusterCache)

			iClusterCache->Discard();

		if (iPageCache)

			iPagePool->Purge();

		if (iFlags&EModified)

			iFlags|=EDamaged;

		iPagePool->Open(Store(),iPoolToken);	// reset the page pool

		}

	else if (!iSharedStore)		// don't touch the store if not shared

		return;

	iStore->Revert();

	}

//

// Ensure we have a cluster cache and return it

//

CClusterCache& CDbStoreDatabase::ClusterCacheL()

	{

	CClusterCache* cache=iClusterCache;

	if (!cache)

		iClusterCache=cache=CClusterCache::NewL(*this);

	return *cache;

	}

//

// Ensure we have a page cache and return the pool

//

MPagePool& CDbStoreDatabase::PagePoolL()

	{

	if (!iPageCache)

		{

		iPageCache=CPageCache::NewL(EPageCachePages);

		iPagePool->Set(*iPageCache);

		}

	return *iPagePool;

	}

//

// Create an incremental object that compacts the store

//

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

	{

	switch (aType)

		{

	case CDbDatabase::EStats:

	case CDbDatabase::ECompact:

		return CCompactor::NewL(aType,Store(),iReclaim,aStep);

	case CDbDatabase::ERecover:

		return RecoverL(aStep);

	default:

		return CDbTableDatabase::UtilityL(aType,aStep);

		}

	}

//

// Create an incremental object to destroy a table

//

EXPORT_C CDbTableDatabase::CStepper* CDbStoreDatabase::RecordDiscarderL(const CDbTableDef& aTable,TInt& aStep)

	{

	CDbStoreTable::CDiscarder* discarder=new(ELeave) CDbStoreTable::CDiscarder;

	CleanupStack::PushL(discarder);

	aStep=discarder->OpenL((CDbStoreTable*)TableL(aTable));

	CleanupStack::Pop();

	return discarder;

	}

//

// Create an incremental object to destroy an index

//

EXPORT_C CDbTableDatabase::CStepper* CDbStoreDatabase::IndexDiscarderL(const CDbTableDef& aTable,const CDbTableIndexDef& anIndex,TInt& aStep)

	{

	CDbStoreIndex::CDiscarder* discarder=new(ELeave) CDbStoreIndex::CDiscarder;

	CleanupStack::PushL(discarder);

	CDbStoreIndex* index=CDbStoreIndex::NewL(*this,(const CDbStoreIndexDef&)anIndex,aTable);

	aStep=discarder->Open(index);

	index->OpenL();

	CleanupStack::Pop();

	return discarder;

	}

//

// Provide a stepper to alter the table data

// if no data to alter, return 0

//

EXPORT_C CDbTableDatabase::CStepper* CDbStoreDatabase::TableAlterL(CDbTableDef& aTable,const HDbColumnSet& aNewSet,TInt& aStep)

	{

	CDbStoreDef& def=STATIC_CAST(CDbStoreDef&,aTable);

//

	aStep=CDbStoreRecords::CardinalityL(Store(),def);

	if (!aStep)

		return NULL; // no data to modify

// check that all added columns are nullable

	HDbColumnSet::TIteratorC col=aNewSet.Begin();

	HDbColumnSet::TIteratorC end=aNewSet.End();

	do

		{

		if (col->iFlags&TDbColumnDef::EAdded && col->iAttributes&TDbCol::ENotNull)

			__LEAVE(KErrArgument);		// added column is not nullable

		} while (++col<end);

//

// check to see if anything is being dropped or changed type

	col=aTable.Columns().Begin();

	end=aTable.Columns().End();

	while (!(col->iFlags&(TDbColumnDef::EDropped|TDbColumnDef::EChangedType|TDbColumnDef::EChangedLen)))

		{

		if (++col==end)

			{	// no changes which affect layout, so no work required

			aStep=0;

			return NULL;

			}

		}

// work required

	CDbStoreTable::CAlter* alter=new(ELeave) CDbStoreTable::CAlter;

	CleanupStack::PushL(alter);

	alter->OpenL((CDbStoreTable*)TableL(def),aNewSet);

	CleanupStack::Pop();

	return alter;

	}

EXPORT_C void CDbStoreDatabase::Reserved_1()

	{

	}

EXPORT_C void CDbStoreDatabase::Reserved_2()

	{

	}