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

#define UNUSED_VAR(a) a = a

const TUint KTableExpiry=0x100000;	// ~1.0s

// Class Blob cleanup

NONSHARABLE_CLASS(CDbBlobCleanup) : public CArrayFixFlat<TDbBlobId>

	{

public:

	static CDbBlobCleanup* NewLC(CDbBlobSpace& aBlobSpace);

	~CDbBlobCleanup();

private:

	inline CDbBlobCleanup(CDbBlobSpace& aBlobSpace);

private:

	CDbBlobSpace& iBlobSpace;

	};

inline CDbBlobCleanup::CDbBlobCleanup(CDbBlobSpace& aBlobSpace)

	: CArrayFixFlat<TDbBlobId>(8),iBlobSpace(aBlobSpace)

	{}

CDbBlobCleanup* CDbBlobCleanup::NewLC(CDbBlobSpace& aBlobSpace)

	{

	CDbBlobCleanup* self=new(ELeave) CDbBlobCleanup(aBlobSpace);

	CleanupStack::PushL(self);

	return self;

	}

CDbBlobCleanup::~CDbBlobCleanup()

	{

	TInt count=Count();

	if (count)

		{

		const TDbBlobId* blob=&(*this)[0];

		const TDbBlobId* const end=blob+count;

		for (;blob<end;++blob)

			iBlobSpace.Delete(*blob);

		}

	}

// Class CDbTable

EXPORT_C CDbTable::CDbTable(CDbTableDatabase& aDatabase,const CDbTableDef& aDef)

	: iDatabase(&aDatabase),iDef(&aDef)

	{

	aDatabase.Open();

	aDatabase.AddTable(*this);		// we reference database

	}

EXPORT_C CDbTable::~CDbTable()

//

// Destroy components

//

	{

	__ASSERT(!InUse());		// cannot be directly deleted

	if (IsActive())

		Disconnect();

	}

void CDbTable::Disconnect()

//

// Disconnect the table from the database collection.

//

	{

	__ASSERT(IsActive());

	Database().RemoveTable(*this);

	TRAPD(errCode, ApplyToComponentsL(CDbRecordBase::DoDelete));

    UNUSED_VAR(errCode);

	}

void CDbTable::Open()

	{

	__ASSERT(IsActive());

	TInt r=++iRef;

	if (r<=0)

		{	// were idle or cached

		if (r<0)

			{

			Cache().Release(*this);	// was cached

			iRef=0;

			}

		Database().Open();

		}

	}

void CDbTable::Close()

//

// We may destroy this object when the last reference goes away

//

	{

	__ASSERT(InUse());

	if (--iRef<0)

		{

		if (!IsActive())

			delete this;		// disconnected table

		else

			{

			CDbTableDatabase& db=Database();

			if (!db.Transaction().IsLocked())

				Idle();			// no transaction, idle now

			db.Close();			// this must be done last to avoid early self destruction

			}

		}

	}

void CDbTable::Idle()

//

// Called when idle, change to cached state

//

	{

	__ASSERT(IsIdle());

	__ASSERT(IsActive());

//

	iRef=ECached;

	Cache().Hold(this,KTableExpiry);	// may delete this

	}

void CDbTable::FlushL()

//

// Ensure all records objects are flushed

//

	{

	__ASSERT(IsActive());

	if (iRef!=ECached)

		ApplyToComponentsL(CDbRecordBase::DoFlushL);

	}

void CDbTable::Abandon()

//

// Discard all components

//

	{

	__ASSERT(IsActive());

	TRAPD(errCode, ApplyToComponentsL(CDbRecordBase::DoAbandon));

    UNUSED_VAR(errCode);

	iIndexesEnd=NULL;	// flags indexes as abandoned

	++iGeneration;

	}

void CDbTable::Release()

//

// Release the table and all its cursors as DDL is about to begin

//

	{

	__ASSERT(IsActive());

	switch (iRef)

		{

	case ECached:

		Cache().Release(*this);

		// fall throught to Idle

	case EIdle:

		delete this;

		break;

	default:

		__ASSERT(InUse());

		Database().Close();

		Disconnect();

		iDatabase=0;		// this marks us as released

		iDef=0;

		break;

		}

	}

void CDbTable::ApplyToBlobsL(RDbRow& aRow,TBlobFuncL aFuncL,CDbBlobCleanup* aCleanup)

	{

	__ASSERT(Def().Columns().HasLongColumns());

	CDbBlobSpace* blobs=BlobsL();

	__ASSERT(blobs);

	TDbColNo col=1;

	HDbColumnSet::TIteratorC iter=Def().Columns().Begin();

	const HDbColumnSet::TIteratorC end=Def().Columns().End();

	do

		{

		if (!TDbCol::IsLong(iter->Type()))

			continue;

		const TDbColumnC column(aRow,col);

		if (column.IsNull())

			continue;

		aFuncL(*blobs,CONST_CAST(TDbBlob&,column.Blob()),iter->Type(),aCleanup);

		} while (++col,++iter<end);

	}

LOCAL_C void DuplicateBlobL(CDbBlobSpace& aBlobStore,TDbBlob& aBlob,TDbColType aType,CDbBlobCleanup* aCleanup)

	{

	__ASSERT(aCleanup);

	if (aBlob.IsInline())

		return;

// need to duplicate blob

	RReadStream old(aBlobStore.ReadLC(aBlob.Id(),aType));

	TDbBlobId& newId=aCleanup->ExtendL();

	newId=KDbNullBlobId;

	RWriteStream dup(aBlobStore.CreateL(newId,aType));

	dup.PushL();

	dup.WriteL(old,aBlob.Size());

	dup.CommitL();

	CleanupStack::PopAndDestroy(2);		// old and dup streams

	aBlob.SetId(newId);		// row is writable

	}

void CDbTable::DuplicateBlobsL(RDbRow& aRow)

//

// duplicate any blobs

//

	{

	if (!Def().Columns().HasLongColumns())

		return;

	CDbBlobCleanup* cleaner=CDbBlobCleanup::NewLC(*BlobsL());

	ApplyToBlobsL(aRow,DuplicateBlobL,cleaner);

	cleaner->Reset();

	CleanupStack::PopAndDestroy();

	}

TBool CDbTable::ExistsL(TDbRecordId aRecordId)

//

// Check that aRecordId is good for this table

//

	{

	__ASSERT(IsActive() && InUse());

	return RecordsL().ExistsL(aRecordId);

	}

void CDbTable::NewRowL(RDbRow& aRow)

//

// Initialise any auto-increment columns in the row

//

	{

	const HDbColumnSet& columns=Def().Columns();

	if (!columns.HasAutoIncrement())

		return;

	TUint value=RecordsL().AutoIncrementL();

	TDbColNo col=1;

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

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

	do

		{

		if (iter->iAttributes&TDbCol::EAutoIncrement)

			{

			// auto-increment only for integral types <=32 bits wide

			__ASSERT(iter->iType<=EDbColUint32);

			TDbColumn column(aRow,col);

			column.SetL(TUint32(value));

			}

		} while (++col,++iter<end);

	}

void CDbTable::ValidateL(const RDbRow& aRow)

//

// Ensure that the column data conforms to type size/flags etc

//

	{

	HDbColumnSet::TIteratorC iter=Def().Columns().Begin();

	const HDbColumnSet::TIteratorC end=Def().Columns().End();

	const TDbCell* const last=aRow.Last();

	for (const TDbCell* column=aRow.First();column<last;++iter,column=column->Next())

		{

		TInt size=column->Length();

		if (size==0)

			{	// check for Null

			if (iter->iAttributes&TDbCol::ENotNull)

				{

				__LEAVE(KErrNotFound);

				return;

				}

			continue;

			}

		const TUint32* data=(const TUint32*)column->Data();

		switch (iter->iType)

			{

		case EDbColBit:

			if (*data>1)

				__LEAVE(KErrOverflow);

			break;

		case EDbColInt8:

			{

			TInt val=*data;

			if (TInt8(val)!=val)

				__LEAVE(KErrOverflow);

			}

			break;

		case EDbColInt16:

			{

			TInt val=*data;

			if (TInt16(val)!=val)

				__LEAVE(KErrOverflow);

			}

			break;

		case EDbColUint8:

			{

			TUint val=*data;

			if (TUint8(val)!=val)

				__LEAVE(KErrOverflow);

			}

			break;

		case EDbColUint16:

			{

			TUint val=*data;

			if (TUint16(val)!=val)

				__LEAVE(KErrOverflow);

			}

			break;

		case EDbColText16:

			size>>=1;

		case EDbColBinary:

		case EDbColText8:

			if (iter->iMaxLength==KDbUndefinedLength)

				break;

			if (size>iter->iMaxLength)

				__LEAVE(KErrOverflow);

			break;

		case EDbColLongBinary:

		case EDbColLongText8:

		case EDbColLongText16:

			if (iter->iMaxLength==KDbUndefinedLength)

				break;

			size=((TDbBlob*)data)->Size();

			if (size==KDbUndefinedLength)

				break;

			if (iter->iType==EDbColText16)

				size>>=1;

			if (size>iter->iMaxLength)

				__LEAVE(KErrOverflow);

			break;

		default:

			break;

			}

		}

	for (;iter<end;++iter)

		{	// check for Null

		if (iter->iAttributes&TDbCol::ENotNull)

			{

			__LEAVE(KErrNotFound);

			return;

			}

		}

	}

void CDbTable::ReadRowL(RDbRow& aRow,TDbRecordId aRecordId)

//

// Read a record from the table

//

	{

	CopyToRowL(aRow,RecordsL().ReadL(aRecordId));

	}

void CDbTable::PrepareAppendL(const RDbTableRow& aRow)

//

// Validate a new record for appending

//

	{

	EnsureIndexesL();

	ValidateL(aRow);

	CDbRecordIndex** end=iIndexesEnd;

	for (CDbRecordIndex** pix=iIndexes;pix<end;++pix)

		{

		CDbRecordIndex& ix=**pix;

		if (ix.IsBroken())

			continue;

		if (ix.FindL(KDbNullRecordId,aRow)==CDbRecordIndex::EKeyMatch)

			__LEAVE(KErrAlreadyExists);	// duplicate found

		}

	}

TDbRecordId CDbTable::AppendRowL(const RDbTableRow& aRow)

//

// Validate and add a new record to the table and any open indexes

//

	{

	CDbRecordSpace& records=RecordsL();

	CopyFromRow(records.NewL(RecordLength(aRow)),aRow);

	TDbRecordId id=records.AppendL();

	CDbRecordIndex** end=iIndexesEnd;

	for (CDbRecordIndex** pix=iIndexes;pix<end;++pix)

		{

		CDbRecordIndex& ix=**pix;

		if (ix.IsBroken())

			continue;

		__DEBUG(TInt dbgchk=) ix.InsertL(id,aRow);

		__ASSERT(dbgchk);

		}

	++iGeneration;

	return id;

	}

void CDbTable::PrepareReplaceL(const RDbTableRow& aRow,TDbRecordId aRecordId)

//

// Validate a record for replacement

//

	{

	EnsureIndexesL();

	ValidateL(aRow);

	TUint32 update=0;

	CDbRecordIndex** end=iIndexes;

	for (CDbRecordIndex** pix=iIndexesEnd;--pix>=end;)

		{

		update<<=1;

		CDbRecordIndex& ix=**pix;

		if (ix.IsBroken())

			continue;

		switch (ix.FindL(aRecordId,aRow))

			{

		case CDbRecordIndex::ENoMatch:		// key has changed in index

			update|=1;

			break;

		case CDbRecordIndex::EKeyMatch:	// duplicate found

			__LEAVE(KErrAlreadyExists);

		case CDbRecordIndex::EEntryMatch:	// no change in index

			break;

			}

		}

	iUpdateMap=update;

	}

void CDbTable::DoReplaceRowL(const RDbRow& aRow,TDbRecordId aRecordId)

	{

	CopyFromRow(RecordsL().ReplaceL(aRecordId,RecordLength(aRow)),aRow);

	++iGeneration;

	}

void CDbTable::ReplaceRowL(RDbTableRow& aRow,TDbRecordId aRecordId)

//

// Replace a record in the table

//

	{

	if (Def().Columns().HasLongColumns())

		CheckInliningL(aRow);

	TUint32 update=iUpdateMap;

	if (update==0)

		{

		DoReplaceRowL(aRow,aRecordId);

		return;

		}

	RDbTableRow oldRow;		// temporary row buffer for old row values

	oldRow.Open(this);

	oldRow.PushL();			// cleanup buffer if there is trouble

	ReadRowL(oldRow,aRecordId);

	DoReplaceRowL(aRow,aRecordId);

	for (CDbRecordIndex** pix=iIndexes;update;++pix,update>>=1)

		{

		if (update&1)

			{

			CDbRecordIndex& index=**pix;

			index.DeleteL(aRecordId,oldRow);

			__DEBUG(TInt dbgchk=) index.InsertL(aRecordId,aRow);

			__ASSERT(dbgchk);

			}

		}

	CleanupStack::PopAndDestroy();	// temp row buffer

	}

LOCAL_C void CheckInlineL(CDbBlobSpace& aBlobStore,TDbBlob& aBlob,TDbColType aType,CDbBlobCleanup*)

	{

	if (!aBlob.IsInline())

		return;

	if (aBlob.Size()>aBlobStore.InlineLimit())

		aBlob.SetId(aBlobStore.CreateL(aType,aBlob.Data(),aBlob.Size()));

	}

void CDbTable::CheckInliningL(RDbRow& aRow)

//

// Ensure that all Blobs are within the current inline limit

//

	{

	ApplyToBlobsL(aRow,CheckInlineL);

	}

LOCAL_C void DiscardBlobL(CDbBlobSpace& aBlobStore,TDbBlob& aBlob,TDbColType,CDbBlobCleanup*)

	{

	if (!aBlob.IsInline())

		aBlobStore.DeleteL(aBlob.Id());

	}

EXPORT_C void CDbTable::DiscardBlobsL(RDbRow& aRow)

//

// Default implemtation xlates the record and then walks the row buffer

//

	{

	ApplyToBlobsL(aRow,DiscardBlobL);

	}

void CDbTable::DeleteRowL(RDbTableRow& aRow,TDbRecordId aRecordId)

//

// Delete the record from the file and unlock it.

//

	{

	EnsureIndexesL();

	if (Def().Columns().HasLongColumns())

		{

		// Read data from the stream but do not delete the stream yet.

		aRow.ReadL(aRecordId);

		}

	CDbRecordIndex** end=iIndexes;

	CDbRecordIndex** pix=iIndexesEnd;

	if (pix!=end)

		aRow.ReadL(aRecordId);

	RecordsL().EraseL(aRecordId);

	while (--pix>=end)

		{

		CDbRecordIndex& ix=**pix;

		if (!ix.IsBroken())

			ix.DeleteL(aRecordId,aRow);

		}

	if (Def().Columns().HasLongColumns())

		{

		// Now delete the stream.

		DiscardBlobsL(aRow);

		}

	++iGeneration;

	}

EXPORT_C CDbRecordSpace& CDbTable::RecordsL()

	{

	__ASSERT(IsActive() && InUse());

	CDbRecordSpace* rec=iRecords;

	if (rec==NULL)

		iRecords=rec=RecordSpaceL();

	if (rec->OpenL())

		__LEAVE(KErrCorrupt);

	return *rec;

	}

EXPORT_C CDbBlobSpace* CDbTable::BlobsL()

	{

	__ASSERT(IsActive() && InUse());

	CDbBlobSpace* blob=iBlobs;

	if (blob==NULL)

		iBlobs=blob=BlobSpaceL();

	if (blob->OpenL())

		__LEAVE(KErrCorrupt);

	return blob;

	}

EXPORT_C CDbRecordIndex& CDbTable::IndexL(const CDbTableIndexDef& aIndex)

//

// Load the index associated with the index definition and ensure it is operational

//

	{

	__ASSERT(IsActive() && InUse());

	// find the matching slot in the indexes array

	CDbRecordIndex** slot=&iIndexes[0];

	for (TSglQueIterC<CDbTableIndexDef> iter(Def().Indexes().AsQue());iter++!=&aIndex;)

		++slot;

	__ASSERT(iIndexesEnd==NULL||(slot>=iIndexes&&slot<iIndexesEnd));

	// load (if required) and open the index

	CDbRecordIndex* index=*slot;

	if (index==0)

		*slot=index=RecordIndexL(aIndex);

	if (index->OpenL())

		__LEAVE(KErrCorrupt);

	return *index;

	}

void CDbTable::EnsureIndexesL()

//

// Ensure that all indexes are open

//

	{

	__ASSERT(IsActive() && InUse());

	if (iIndexesEnd==NULL)

		{

		CDbRecordIndex** pp=iIndexes;

		TSglQueIterC<CDbTableIndexDef> iter(Def().Indexes().AsQue());

		for (const CDbTableIndexDef* xDef;(xDef=iter++)!=NULL;++pp)

			{

			CDbRecordIndex* ix=*pp;

			if (ix==NULL)

				*pp=ix=RecordIndexL(*xDef);

			ix->OpenL();	// ignore broken-ness

			}

		iIndexesEnd=pp;

		}

	}

CDbRecordIter* CDbTable::IteratorL()

	{

	return RecordsL().IteratorL();

	}

CDbRecordIter* CDbTable::IteratorL(const CDbTableIndexDef& aIndex,TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)

//

// create an interator for the index parameter

//

	{

	return IndexL(aIndex).IteratorL(aInclusion,aLowerBound,aUpperBound);

	}

EXPORT_C TInt CDbTable::IndexSpanL(const CDbTableIndexDef&,TUint,const TDbLookupKey*,const TDbLookupKey*)

//

// Default implementation: no statistics are available

//

	{

	return EUnavailableSpan;

	}

CDbRecordIter* CDbTable::IteratorL(const TDesC& aIndex)

//

// create an interator for the index named

//

	{

	return IteratorL(Def().Indexes().FindL(aIndex));

	}

void CDbTable::ApplyToComponentsL(void (*anOperationL)(CDbRecordBase*))

//

// Invoke anOperation on all components of the table

//

	{

	if (iRecords)

		anOperationL(iRecords);

	if (iBlobs)

		anOperationL(iBlobs);

	CDbRecordIndex** const ixs=iIndexes;

	CDbRecordIndex** pix=iIndexesEnd;

	if (pix==NULL)

		pix=&iIndexes[KDbTableMaxIndexes];

	while (--pix>=ixs)

		if (*pix)

			anOperationL(*pix);

	}

// Class CDbtable::TValid

// this class is used by the cursor to check that it is still operational

CDbTable::TValid::TValid(CDbTable& aTable)

	:iTable(aTable)

	{

	__ASSERT(aTable.IsActive());

	iRollback.Construct(aTable.Database().Transaction().RollbackGeneration());

	}

TBool CDbTable::TValid::Reset()

	{

	TBool b=Table().IsActive();

	if (b)

		iRollback.Mark();

	return b;

	}

void CDbTable::TValid::CheckL() const

	{

	CDbTableDatabase* d=Table().iDatabase;

	if (!d)

		__LEAVE(KErrDisconnected);

	else

		d->Transaction().ReadyL();

	if (iRollback.Changed())

		__LEAVE(KErrNotReady);

	}