// 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:
// DBMS server proxy cursor
// 
//

#include "SD_STD.H"

const TDbBlobId KUnknownBlobId=~0u;

// Class HDbsColumns

class HDbsColumns
	{
public:
	static HDbsColumns* NewL(TInt aCount);
	inline void Set(const TUint8* aPtr);
	inline TPtr8 Ptr();
	inline TInt Count() const;
	inline TDbColType Type(TDbColNo aCol) const;
	void Check(TDbColNo aCol) const;
private:
	inline HDbsColumns(TInt aCount);
private:
	TInt iCount;
	TUint8 iType[1];
	};

inline HDbsColumns::HDbsColumns(TInt aCount)
	:iCount(aCount)
	{}
inline void HDbsColumns::Set(const TUint8* aPtr)
	{Mem::Copy(iType,aPtr,iCount);}
inline TPtr8 HDbsColumns::Ptr()
	{return TPtr8(iType,iCount);}
inline TInt HDbsColumns::Count() const
	{return iCount;}
inline TDbColType HDbsColumns::Type(TDbColNo aCol) const
	{__DEBUG(Check(aCol));return TDbColType(iType[aCol-1]);}

HDbsColumns* HDbsColumns::NewL(TInt aCount)
	{
	return new(User::AllocL(_FOFF(HDbsColumns,iType[aCount]))) HDbsColumns(aCount);
	}

void HDbsColumns::Check(TDbColNo aColNo) const
	{
	__ASSERT_ALWAYS(aColNo>0&&aColNo<=iCount,Panic(EDbsInvalidColumn));
	}

// Class CDbsCursor

CDbsCursor::CDbsCursor()
	:iState(EAtBeginning)
	{}

CDbsCursor* CDbsCursor::NewL(const RDbsObject& aDbs,TDbsFunction aFunction,TIpcArgs& aArgs)
	{
	CDbsCursor* self=new(ELeave) CDbsCursor;
	CleanupStack::PushL(self);
	self->ConstructL(aDbs,aFunction,aArgs);
	CleanupStack::Pop();
	return self;
	}

void CDbsCursor::ConstructL(const RDbsObject& aDbs,TDbsFunction aFunction,TIpcArgs& aArgs)
//
// construct a cursor from the supplied parameters
// Retrieve the column types, in one pass if possible
//
	{
	TPckgBuf<TDbsColumns> cols;
	aArgs.Set(3,&cols);
	iObject.OpenL(aDbs,aFunction,aArgs);
	iColumns=HDbsColumns::NewL(cols().iCount);
	if (cols().iCount<=cols().EMax)
		iColumns->Set(cols().iData);	// we have the column types
	else
		{	// too many for the fixed buffer, make a second call to get the columns
		TPtr8 ptr=iColumns->Ptr();
		aArgs.Set(3,&ptr);
		iObject.SendReceiveL(EDbsCursorColumnTypes,aArgs);
		}
	}

CDbsCursor::~CDbsCursor()
	{
	iObject.Close();
	delete iColumns;
	iRow.Close();
	}

TDbColType CDbsCursor::Type(TDbColNo aCol) const
	{
	iColumns->Check(aCol);
	return iColumns->Type(aCol);
	}

void CDbsCursor::Reset()
	{
	iState=EAtBeginning;
	iObject.SendReceive(EDbsCursorReset);
	}

TBool CDbsCursor::EvaluateL()
	{
	iState=EUnknown;
	return iObject.SendReceiveL(EDbsCursorEvaluate);
	}

void CDbsCursor::Evaluate(TRequestStatus& aStatus)
	{
	iState=EUnknown;
	iObject.SendReceive(EDbsCursorEvaluate,aStatus);
	}

TBool CDbsCursor::Unevaluated()
	{
	return iObject.SendReceive(EDbsCursorUnevaluated);
	}

void CDbsCursor::SetIndexL(const TDesC* anIndex)
	{
	iObject.SendReceiveL(EDbsCursorSetIndex,TIpcArgs(anIndex));
	iState=EAtBeginning;
	}

TBool CDbsCursor::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)
	{
	TPtrC8 key(TDbsParam::PrepareLC(aKey));
	iState=EUnknown;
	TBool found=iObject.SendReceiveL(EDbsCursorSeek,TIpcArgs(&key,key.Length(),aComparison));
	CleanupStack::PopAndDestroy();	// key
	if (found)
		iState=EAtRow;
	return found;
	}

TBool CDbsCursor::AtBeginning()
	{
	if (iState==EUnknown && iObject.SendReceive(EDbsCursorAtBeginning)>0)
		iState=EAtBeginning;
	return iState==EAtBeginning;
	}

TBool CDbsCursor::AtEnd()
	{
	if (iState==EUnknown && iObject.SendReceive(EDbsCursorAtEnd)>0)
		iState=EAtEnd;
	return iState==EAtEnd;
	}

TBool CDbsCursor::AtRow()
	{
	if (iState==EUnknown && iObject.SendReceive(EDbsCursorAtRow)>0)
		iState=EAtRow;
	return iState>=EAtRow;
	}

TInt CDbsCursor::CountL(RDbRowSet::TAccuracy aAccuracy)
//
// valid response is >=0 + undefined (==-1)
// server returns +1 for non-error conditions
//
	{
	return iObject.SendReceiveL(EDbsCursorCount,TIpcArgs(aAccuracy))-1;
	}

TBool CDbsCursor::GotoL(RDbRowSet::TPosition aPosition)
	{
	TBool atrow=RetrieveL(EDbsCursorGotoPos,aPosition);
	if (atrow)
		iState=ERetrieve;
	else
		{
		switch (aPosition)
			{
		default:
			__ASSERT(0);
		case RDbRowSet::EEnd:
		case RDbRowSet::EFirst:
		case RDbRowSet::ENext:
			iState=EAtEnd;
			break;
		case RDbRowSet::EBeginning:
		case RDbRowSet::ELast:
		case RDbRowSet::EPrevious:
			iState=EAtBeginning;
			break;
			}
		}
	return atrow;
	}

void CDbsCursor::Bookmark(TDbBookmark::TMark& aMark)
	{
	TPckg<TDbBookmark::TMark> pckg(aMark);
	iObject.SendReceive(EDbsCursorBookmark,TIpcArgs(TIpcArgs::ENothing,TIpcArgs::ENothing,TIpcArgs::ENothing,&pckg));
	}

void CDbsCursor::GotoL(const TDbBookmark::TMark& aMark)
	{
	TPckgC<TDbBookmark::TMark> pckg(aMark);
	iState=EUnknown;
	iObject.SendReceiveL(EDbsCursorGotoBookmark,TIpcArgs(&pckg));
	}

LOCAL_C void CancelCursor(TAny* aPtr)
	{
	STATIC_CAST(CDbCursor*,aPtr)->Cancel();
	}

TBool CDbsCursor::RetrieveL(TDbsFunction aFunction,TInt aArg0)
//
// Read the row buffer
//
	{
	iState=EUnknown;
	TInt size;
	for (;;)
		{
		TInt max=iRow.MaxSize();
		TPtr8 row((TUint8*)iRow.First(),max);
		size=iObject.SendReceiveL(aFunction,TIpcArgs(aArg0,TIpcArgs::ENothing,max,&row))-1;
		if (size<0)
			return EFalse;		// no row to retrieve
		if (size<=max)
			break;
		// didn't fit! Grow the buffer
		if (aFunction!=EDbsCursorRetrieveRow)
			{
			CleanupStack::PushL(TCleanupItem(CancelCursor,this));	// in case this goes wrong!
			aFunction=EDbsCursorRetrieveRow;
			}
		iRow.GrowL(size);
		}
	iRow.SetSize(size);
	if (aFunction==EDbsCursorRetrieveRow)
		CleanupStack::Pop();
	return ETrue;
	}

void CDbsCursor::GetL()
	{
	if (iState!=ERetrieve)
		RetrieveL(EDbsCursorGet);
	iState=ERead;
	}

void CDbsCursor::InsertL(TInsert aClearRow)
	{
	RetrieveL(EDbsCursorInsert,aClearRow);
	iState=EWrite;
	iChangedBlob=EFalse;
	}

void CDbsCursor::UpdateL()
	{
	RetrieveL(EDbsCursorUpdate);
	iState=EWrite;
	iChangedBlob=EFalse;
	}

void CDbsCursor::Cancel()
	{
	if (iState==EUnknown || iState==EWrite)
		iObject.SendReceive(EDbsCursorCancel);
	}

void CDbsCursor::PutL()
	{
	TInt size=iRow.Size();
	TPtrC8 row((const TUint8*)iRow.First(),size);
	iObject.SendReceiveL(EDbsCursorPut,TIpcArgs(&row,size,iChangedBlob));// if iChangedBlob false, server can optimize put
	iState=ERead;		// we can still look at the row we put
	}

void CDbsCursor::DeleteL()
	{
	iState=EUnknown;
	iObject.SendReceiveL(EDbsCursorDelete);
	}

TInt CDbsCursor::ColumnCount()
	{
	return iColumns->Count();
	}

void CDbsCursor::ColumnsL(CDbColSet& aColSet)
//
// optimise the retreival of all columns
//
	{
	TIpcArgs m;
	RReadStream in(HDbsBuf::NewLC(iObject,EDbsCursorColumns,m));
	in>>aColSet;
	CleanupStack::PopAndDestroy();	// buffer
	}

void CDbsCursor::ColumnDef(TDbCol& aCol,TDbColNo aColNo)
	{
	TPckg<TDbCol> pckg(aCol);
	iColumns->Check(aColNo);
	iObject.SendReceive(EDbsCursorColumnDef,TIpcArgs(aColNo,TIpcArgs::ENothing,TIpcArgs::ENothing,&pckg));
	}

TDbColType CDbsCursor::ColumnType(TDbColNo aCol)
	{
	return Type(aCol);
	}

RDbRow* CDbsCursor::RowBuffer()
//
// Invoked by the server-- should not be called
//
	{
	__ASSERT(0);
	return 0;
	}

TDbColumnC CDbsCursor::ColumnC(TDbColNo aCol)
//
// check row is valid for extraction
//
	{
	__ASSERT_ALWAYS(iState>=ERead,Panic(EDbsNoRowData));
	return TDbColumnC(iRow,aCol);
	}

TDbColumn CDbsCursor::Column(TDbColNo aCol)
//
// check row is valid for writing
//
	{
	__ASSERT_ALWAYS(iState==EWrite,Panic(EDbsNotInUpdate));
	return TDbColumn(iRow,aCol);
	}

void CDbsCursor::ReplaceBlobL(TDbColumn& aCol)
//
// We no longer know what the shape of a blob is, mark it as "unknown"
//
	{
	iChangedBlob=ETrue;
	aCol.SetBlobL(KUnknownBlobId);
	}

void CDbsCursor::SetNullL(TDbColNo aCol)
//
// Make the column Null
//
	{
	TDbColumn col=Column(aCol);
	if (!TDbCol::IsLong(Type(aCol)))
		col.SetNull();
	else if (!TDbColumnC(col).IsNull())
		{
		ReplaceBlobL(col);
		iObject.SendReceiveL(EDbsCursorSetNull,TIpcArgs(aCol));
		}
	}

TInt CDbsCursor::ColumnSize(TDbColNo aCol)
	{
	TDbColumnC col(ColumnC(aCol));
	if (!TDbCol::IsLong(Type(aCol)))
		return col.Size();
	TInt size=col.Blob().Size();
	if (size>=0)
		return size;
	// unknown size, so ask the server
	return iObject.SendReceive(EDbsCursorColumnSize,TIpcArgs(aCol));
	}

MStreamBuf* CDbsCursor::ColumnSourceL(TDbColNo aCol)
	{
	TDbColumnC col(ColumnC(aCol));
	if (!TDbCol::IsLong(iColumns->Type(aCol)))
		return HDbsReadBuf::NewL(col.PtrC8());
	// blobs
	const TDbBlob& blob=col.Blob();
	if (blob.IsInline())
		return HDbsReadBuf::NewL(blob.PtrC8());
	// get it from the server
	TIpcArgs args(aCol);
	return HDbsBuf::NewL(iObject,EDbsCursorColumnSource,args);
	}

MStreamBuf* CDbsCursor::ColumnSinkL(TDbColNo aCol)
	{
	TDbColumn col(Column(aCol));
	ReplaceBlobL(col);
	TIpcArgs args(aCol);
	return HDbsBuf::NewL(iObject,EDbsCursorColumnSink,args);
	}

CDbRowConstraint* CDbsCursor::OpenConstraintL(const TDbQuery& aQuery)
	{
	const TDesC& des = aQuery.Query();
	CDbsConstraint* c=new(ELeave) CDbsConstraint();
	CleanupStack::PushL(c);
	c->iObject.OpenL(iObject,EDbsCursorOpenConstraint,TIpcArgs(&des,aQuery.Comparison()));
	CleanupStack::Pop();
	return c;
	}

TBool CDbsCursor::MatchL(CDbRowConstraint& aConstraint)
	{
	TInt handle = STATIC_CAST(CDbsConstraint&,aConstraint).iObject.Handle();
	return iObject.SendReceiveL(EDbsCursorMatch,TIpcArgs(handle));
	}

TInt CDbsCursor::FindL(RDbRowSet::TDirection aDirection,const TDbQuery& aCriteria)
//
// Server returns result-KErrNotFound, to ensure non-leaving on not found
//
	{
	const TDesC& des = aCriteria.Query();
	iState=EUnknown;
	TInt f=iObject.SendReceiveL(EDbsCursorFind,TIpcArgs(&des,aCriteria.Comparison(),aDirection))+KErrNotFound;
	if (f>=0)
		iState=EAtRow;
	return f;
	}

// Class CDbsConstraint

CDbsConstraint::~CDbsConstraint()
	{
	iObject.Close();
	}