// 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 CDbTableCursor::HColumns

 class CDbTableCursor::HColumns

 	{

 public:

 	static HColumns* NewL(const CDbDataSource* aSource);

 	inline TInt Count() const

 		{return iCount;}

 	inline TDbColType Type(TDbColNo aCol) const

 		{__DEBUG(Check(aCol));return TDbColType(iType[aCol-1]);}

 	void Check(TDbColNo aCol) const;

 private:

 	TInt iCount;

 	TUint8 iType[1];

 	};

 CDbTableCursor::HColumns* CDbTableCursor::HColumns::NewL(const CDbDataSource* aSource)

 	{

 	TInt count=aSource->ColumnCount();

 	HColumns* self=(HColumns*)User::AllocL(_FOFF(HColumns,iType[count]));

 	self->iCount=count;

 	TUint8* pp=&self->iType[0];

 	for (TDbColNo ii=1;ii<=count;++ii,++pp)

 		*pp=aSource->ColumnDef(ii).iType;

 	return self;

 	}

 void CDbTableCursor::HColumns::Check(TDbColNo aColNo) const

 	{

 	__ASSERT_ALWAYS(TUint(aColNo-1)<TUint(iCount),Panic(EDbInvalidColumn));

 	}

 // Class CDbTableCursor::CConstraint

 NONSHARABLE_CLASS(CDbTableCursor::CConstraint) : public CDbRowConstraint

 	{

 public:

 	CConstraint(CDbTableCursor& aCursor,CSqlSearchCondition* aSearchCondition,TDbTextComparison aComparison);

 	~CConstraint();

 //

 	inline TBool Check(CDbTableCursor& aCursor) const;

 	inline TBool MatchL() const;

 private:

 	CDbTableCursor& iCursor;

 	CSqlSearchCondition* iSearchCondition;

 	const TTextOps& iTextOps;

 	};

 CDbTableCursor::CConstraint::CConstraint(CDbTableCursor& aCursor,CSqlSearchCondition* aSearchCondition,TDbTextComparison aComparison)

 	: iCursor(aCursor), iSearchCondition(aSearchCondition), iTextOps(TTextOps::Ops(aComparison))

 	{}

 CDbTableCursor::CConstraint::~CConstraint()

 	{

 	delete iSearchCondition;

 	}

 inline TBool CDbTableCursor::CConstraint::Check(CDbTableCursor& aCursor) const

 	{return &iCursor==&aCursor;}

 inline TBool CDbTableCursor::CConstraint::MatchL() const

 	{return iSearchCondition->EvaluateL(iTextOps);}

 // Class CDbTableCursor

 inline void CDbTableCursor::CheckStateL() const

 	{iValid.CheckL();}

 inline RDbTransaction& CDbTableCursor::Transaction()

 	{__ASSERT(iValid);return iValid.Transaction();}

 inline TBool CDbTableCursor::InUpdate() const

 	{return iFlags&(EUpdating|EInserting);}

 CDbTableCursor::CDbTableCursor(RDbAccessPlan& aPlan,RDbRowSet::TAccess aAccess)

 	: iState(ERowBeginning),iValid(aPlan.Table()),iDataSource(aPlan.Adopt())

 	{

 	switch (aAccess)

 		{

 	default:

 		__ASSERT(0);

 	case RDbRowSet::EUpdatable:

 		iFlags=EUpdatable|EReadable;

 		break;

 	case RDbRowSet::EReadOnly:

 		iFlags=EReadable;

 		break;

 	case RDbRowSet::EInsertOnly:

 		iFlags=EUpdatable;

 		break;

 		}

 	}

 CDbTableCursor::~CDbTableCursor()

 	{

 	Cancel();

 	delete iDataSource;

 	delete iColumns;

 	}

 CDbTableCursor* CDbTableCursor::NewL(RDbAccessPlan& aPlan,RDbRowSet::TAccess aAccess)

 	{

 	CDbTableCursor* self=new(ELeave) CDbTableCursor(aPlan,aAccess);

 	CleanupStack::PushL(self);

 	self->iColumns=HColumns::NewL(self->iDataSource);

 	self->Reset();

 	CleanupStack::Pop();

 	return self;

 	}

 TDbColType CDbTableCursor::Type(TDbColNo aCol) const

 	{

 	iColumns->Check(aCol);

 	return iColumns->Type(aCol);

 	}

 void CDbTableCursor::Reset()

 //

 // Reset the cursor for re-evaluation

 //

 	{

 	AssertNotInUpdate();

 	if (iValid.Reset())

 		{

 		iDataSource->Reset();

 		iState=ERowBeginning;

 		}

 	}

 TBool CDbTableCursor::EvaluateL()

 //

 // Do a unit of evaluation work

 //

 	{

 	AssertNotInUpdate();

 	CheckStateL();

 	TInt work=256;

 	TBool atRow=EFalse;

 	TBool more=iDataSource->EvaluateL(work,iRecord,atRow);

 	if (atRow)

 		{	// evaluation results in a record appearing under the cursor

 		switch (iState)

 			{

 		case ERowEnd:

 		case ERowBeginning:

 			iState=ERowOK;

 			break;

 		case ERowDeletedAtEnd:

 			iState=ERowDeletedAtNext;

 			break;

 		default:

 			break;

 			}

 		}

 	return more?1:0;

 	}

 void CDbTableCursor::Evaluate(TRequestStatus& aStatus)

 //

 // Asynchronous evaluation: invoke synchronous version

 //

 	{

 	TRequestStatus* pStatus=&aStatus;

 	User::RequestComplete(pStatus,CDbCursor::Evaluate());

 	}

 TBool CDbTableCursor::Unevaluated()

 //

 // Report if there is evaluation to be done

 //

 	{

 	return iValid ? iDataSource->Unevaluated() : EFalse;

 	}

 TInt CDbTableCursor::CountL(RDbRowSet::TAccuracy aAccuracy)

 	{

 	AssertNotInUpdate();

 	CheckReadL();

 	TInt count=iDataSource->CountL();

 	return (count==KDbUndefinedCount && aAccuracy==RDbRowSet::EEnsure)

 		? CDbCursor::CountL(aAccuracy)

 		: count;

 	}

 TBool CDbTableCursor::AtBeginning()

 	{

 	return iState==ERowBeginning;

 	}

 TBool CDbTableCursor::AtEnd()

 	{

 	return iState==ERowEnd;

 	}

 TBool CDbTableCursor::AtRow()

 	{

 	return (iState==ERowOK||(iFlags&EInserting));

 	}

 TBool CDbTableCursor::GotoL(RDbRowSet::TPosition aPosition)

 //

 // Move the cursor in the requested direction

 // return whether we are at a row or not

 //

 	{

 	AssertNotInUpdate();

 	CheckReadL();

 	iFlags&=~ERead;

 	switch (aPosition)

 		{

 	default:

 		__ASSERT(0);

 	case RDbRowSet::EFirst:

 	case RDbRowSet::ELast:

 		break;

 	case RDbRowSet::ENext:

 		switch (iState)

 			{

 		default:

 			__ASSERT(0);

 		case ERowInLimbo:	// in between previous and next, must evaluate

 		case ERowOK:

 			break;

 		case ERowBeginning:		// goto first record

 			aPosition=RDbRowSet::EFirst;

 			break;

 		case ERowEnd:

 		case ERowInvalid:

 			Panic(EDbInvalidRow);

 			break;

 		case ERowDeletedAtNext:	// already have the id

 			if (iDataSource->GotoL(iRecord))

 				{	// and the record is still there

 				iState=ERowOK;

 				return ETrue;

 				}

 			break;

 		case ERowDeletedAtEnd:	// straight to end

 			iState=ERowEnd;

 			return EFalse;

 			}

 		break;

 	case RDbRowSet::EPrevious:

 		switch (iState)

 			{

 		default:

 			__ASSERT(0);

 		case ERowOK:

 		case ERowDeletedAtNext:		// goto previous will do what we want

 		case ERowInLimbo:	// in between previous and next, must evaluate

 			break;

 		case ERowEnd:				// goto last row

 		case ERowDeletedAtEnd:		// previous is last row

 			aPosition=RDbRowSet::ELast;

 			break;

 		case ERowBeginning:

 		case ERowInvalid:

 			Panic(EDbInvalidRow);

 			break;

 			}

 		break;

 	case RDbRowSet::EBeginning:

 		iState=ERowBeginning;

 		return EFalse;

 	case RDbRowSet::EEnd:

 		iState=ERowEnd;

 		return EFalse;

 		}

 	iState=ERowInvalid;

 	switch (iDataSource->GotoL(TDbPosition(aPosition),iRecord))

 		{

 	default:

 		__ASSERT(0);

 	case CDbDataSource::ESynchFailure:

 		__LEAVE(KErrNotReady);

 	case CDbDataSource::ESuccess:

 		iState=ERowOK;

 		return ETrue;

 	case CDbDataSource::ENoRow:

 		iState=TUint8(aPosition<RDbRowSet::EPrevious ? ERowEnd : ERowBeginning);

 		return EFalse;

 		}

 	}

 void CDbTableCursor::Bookmark(TDbBookmark::TMark& aMark)

 //

 // Create a bookmark for the current cursor state

 // Can bookmark ANY position.

 //

 	{

 	AssertNotInUpdate();

 	aMark.iMark[0]=iState;

 	aMark.iMark[1]=iRecord.Value();

 	}

 void CDbTableCursor::GotoL(const TDbBookmark::TMark& aMark)

 //

 // Reestablish the cursor state from a bookmark (if possible)

 //

 	{

 	AssertNotInUpdate();

 	CheckStateL();

 	iState=ERowInvalid;

 	iRecord=aMark.iMark[1];

 	TState state=TState(aMark.iMark[0]);

 	switch (state)

 		{

 	default:

 		Panic(EDbInvalidBookmark);

 	case ERowBeginning:

 	case ERowEnd:

 	case ERowDeletedAtEnd:

 	case ERowInLimbo:

 	case ERowInvalid:

 		break;

 	case ERowDeletedAtNext:

 	case ERowOK:

 		if (!iDataSource->GotoL(iRecord))

 			__LEAVE(KErrNotFound);

 		break;

 		}

 	iState=TUint8(state);

 	}

 void CDbTableCursor::GetL()

 //

 // read the current row into the row buffer for access

 //

 	{

 	AssertValidRow();

 	CheckStateL();

 	iFlags&=~ERead;

 	iDataSource->ReadRowL(iRecord);

 	iFlags|=ERead;

 	}

 void CDbTableCursor::InsertL(TInsert aClearRow)

 //

 // Insert a new row. If aCLearRow==aCopy, then copy the current row

 //

 	{

 	AssertNotInUpdate();

 	CheckUpdateL();

 	Transaction().DMLPrepareL(*this);

 	if (aClearRow==ECopy)

 		{

 		AssertValidRow();

 		iFlags&=~ERead;	// in case of failure in NewRowL

 		iDataSource->NewRowL(iRecord);

 		}

 	else

 		iDataSource->NewRowL(KDbNullRecordId);

 	iFlags|=EInserting|ERead;

 	Transaction().DMLBegin();

 	}

 void CDbTableCursor::UpdateL()

 	{

 	CheckUpdateL();

 	Transaction().DMLPrepareL(*this);

 	GetL();

 	iFlags|=EUpdating;

 	Transaction().DMLBegin();

 	}

 void CDbTableCursor::Cancel()

 	{

 	AssertNoStreams();

 	if (InUpdate())

 		{

 		RDbTransaction& t=Transaction();

 		if (iFlags&EDirty)

 			t.DMLTouch();			// we've mucked about with BLOBs, so force true roll-back

 		t.DMLRollback();

 		if (iFlags&EUpdating)

 			{

 			TRAP_IGNORE(iDataSource->ReadRowL(KDbNullRecordId));	// row buffer contains NULL row	(cannot fail)

 			}

 		iFlags&=(EUpdatable|EReadable);

 		}

 	}

 void CDbTableCursor::PutL()

 	{

 	AssertInUpdate();

 	CheckStateL();

 	CDbDataSource::TWrite mode=iFlags&EUpdating ? CDbDataSource::EReplace : CDbDataSource::EAppend;

 	iDataSource->PrepareToWriteRowL(mode);

 	RDbTransaction& t=Transaction();

 	t.DMLTouch();

 	iFlags&=~EDirty;

 	iRecord=iDataSource->WriteRowL(mode,iFlags&EReadable ? CDbDataSource::ESynch : CDbDataSource::ENoSynch);

 	t.DMLCommitL();

 	if ((iFlags&(EInserting|EReadable))==(EInserting|EReadable))

 		iState=ERowOK;

 	iFlags&=(EUpdatable|EReadable|ERead);

 	}

 void CDbTableCursor::DeleteL()

 	{

 	AssertValidRow();

 	CheckUpdateL();

 	RDbTransaction& t=Transaction();

 	t.DMLPrepareL(*this);

 	t.DMLBeginLC();

 	CDbDataSource::TDelete del=iDataSource->DeleteRowL(iRecord);

 	t.DMLCommitL();

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

 	iState=TUint8(del+ERowDeletedAtNext);

 	}

 TInt CDbTableCursor::ColumnCount()

 	{

 	return iColumns->Count();

 	}

 void CDbTableCursor::ColumnDef(TDbCol& aCol,TDbColNo aColNo)

 	{

 	iColumns->Check(aColNo);

 	if (iValid)

 		iDataSource->ColumnDef(aColNo).AsTDbCol(aCol);

 	}

 TDbColType CDbTableCursor::ColumnType(TDbColNo aCol)

 	{

 	return Type(aCol);

 	}

 void CDbTableCursor::ReplaceBlobL(TDbColumn& aCol)

 	{

 	CheckStateL();

 	const TDbBlob& blob=TDbColumnC(aCol).Blob();

 	if (!blob.IsInline())

 		{

 		iFlags|=EDirty;

 		BlobsL().DeleteL(blob.Id());

 		}

 	}

 void CDbTableCursor::AddBlobSource()

 //

 // Increment the source count and take a read-lock on the database

 //

 	{

 	AddSource();

 	Transaction().ReadBegin(*this);

 	}

 void CDbTableCursor::ReleaseBlobSource()

 //

 // Decrement the source count and release the read-lock on the database

 //

 	{

 	ReleaseSource();

 	Transaction().ReadRelease(*this);

 	}

 MStreamBuf* CDbTableCursor::ColumnSourceL(TDbColNo aCol)

 	{

 	TDbColumnC col(ColumnC(aCol));

 	if ((iFlags&EWriteBuf) || iReadBuf==EMaxReadBuf)

 		__LEAVE(KErrInUse);			// only allow 1-write or 255-read streambufs

 	TDbColType type=iColumns->Type(aCol);

 	if (!TDbCol::IsLong(type))

 		return HMemBuf::NewL(*this,col.PtrC8());

 	// blobs

 	const TDbBlob& blob=col.Blob();

 	if (blob.IsInline())

 		return HMemBuf::NewL(*this,blob.PtrC8());

 	// if small enough, pull the blob data through immediately and avoid locking the database

 	if (blob.Size()<=HHeapBuf::EMaxBlobBuffer)

 		return HHeapBuf::NewL(*this,blob,type);

 	//

 	CheckStateL();

 	Transaction().ReadPrepareL(*this);

 	HReadBuf* buf=HReadBuf::NewLC(*this);

 	buf->Set(BlobsL().ReadL(blob.Id(),type));

 	CleanupStack::Pop();

 	return buf;

 	}

 MStreamBuf* CDbTableCursor::ColumnSinkL(TDbColNo aCol)

 	{

 	TDbColType type=Type(aCol);

 	__ASSERT_ALWAYS(TDbCol::IsLong(type),Panic(EDbWrongType));

 	TDbColumn col=Column(aCol);

 	ReplaceBlobL(col);

 	iFlags|=EDirty;

 	return HWriteBuf::NewL(*this,col,type);

 	}

 void CDbTableCursor::SetNullL(TDbColNo aCol)

 //

 // Make the column Null

 //

 	{

 	TDbColumn col=Column(aCol);

 	if (TDbCol::IsLong(Type(aCol)))

 		ReplaceBlobL(col);

 	col.SetNull();

 	}

 TInt CDbTableCursor::ColumnSize(TDbColNo aCol)

 	{

 	TDbColumnC col(ColumnC(aCol));

 	return TDbCol::IsLong(Type(aCol)) ? col.Blob().Size() : col.Size();

 	}

 RDbRow* CDbTableCursor::RowBuffer()

 //

 // Invoked by the server for whole-row access where possible

 //

 	{

 	__ASSERT(iFlags&ERead);

 	return iDataSource->RowBuffer();

 	}

 TDbColumnC CDbTableCursor::ColumnC(TDbColNo aCol)

 //

 // check row is valid for extraction

 //

 	{

 	__ASSERT_ALWAYS(iFlags&ERead,Panic(EDbRowNotRead));

 	return iDataSource->Column(aCol);

 	}

 TDbColumn CDbTableCursor::Column(TDbColNo aCol)

 //

 // check row is valid for writing

 //

 	{

 	AssertInUpdate();

 	return iDataSource->Column(aCol);

 	}

 void CDbTableCursor::SetIndexL(const TDesC* anIndex)

 	{

 	AssertNotInUpdate();

 	CheckReadL();

 	iDataSource->SetIndexL(anIndex);

 	iState=ERowBeginning;

 	}

 TBool CDbTableCursor::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)

 	{

 	AssertNotInUpdate();

 	CheckReadL();

 	iFlags&=~ERead;

 	iState=ERowInvalid;

 	TBool atrow=iDataSource->SeekL(aKey,aComparison,iRecord);

 	if (atrow)

 		iState=ERowOK;

 	return atrow;

 	}

 CDbRowConstraint* CDbTableCursor::OpenConstraintL(const TDbQuery& aCriteria)

 //

 // Construct a constraint for this rowset

 //

 	{

 	CSqlSearchCondition* sc=iDataSource->ParseConstraintLC(aCriteria.Query());

 	CDbRowConstraint* constraint=new(ELeave) CConstraint(*this,sc,aCriteria.Comparison());

 	CleanupStack::Pop();

 	return constraint;

 	}

 TBool CDbTableCursor::MatchL(CDbRowConstraint& aConstraint)

 	{

 	CConstraint& c=STATIC_CAST(CConstraint&,aConstraint);

 	__ASSERT_ALWAYS(c.Check(*this),Panic(EDbRowSetConstraintMismatch));

 	GetL();

 	return c.MatchL();

 	}

 void CDbTableCursor::CheckReadL() const

 //

 // Ensure we are a readable cursor

 //

 	{

 	CheckStateL();

 	if ((iFlags&EReadable)==0)

 		__LEAVE(KErrWrite);

 	}

 void CDbTableCursor::CheckUpdateL() const

 //

 // Ensure we are a writable cursor

 //

 	{

 	CheckStateL();

 	if ((iFlags&EUpdatable)==0)

 		__LEAVE(KErrWrite);

 	}

 void CDbTableCursor::AssertNoStreams() const

 	{

 	__ASSERT_ALWAYS((iFlags&EWriteBuf)==0 && iReadBuf==0,Panic(EDbStreamOpen));

 	}

 void CDbTableCursor::AssertNotInUpdate() const

 	{

 	__ASSERT_ALWAYS(!InUpdate(),Panic(EDbInUpdate));

 	AssertNoStreams();

 	}

 void CDbTableCursor::AssertInUpdate() const

 	{

 	__ASSERT_ALWAYS(InUpdate(),Panic(EDbNotInUpdate));

 	AssertNoStreams();

 	}

 void CDbTableCursor::AssertValidRow() const

 	{

 	AssertNotInUpdate();

 	__ASSERT_ALWAYS(iState==ERowOK||(iFlags&EInserting),Panic(EDbInvalidRow));

 	}