// 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:
// SQL DML statements for Table framework
// 
//

#include "UT_STD.H"

// Class CSqlValues

inline CSqlValues::TEntry::TEntry(const RSqlLiteral& aValue)
	:iValue(aValue)
	{}

CSqlValues::CSqlValues()
	:iValues(EGranularity)
	{}

CSqlValues::~CSqlValues()
//
// close all the literal objects
//
	{
	for (TInt ii=iValues.Count();--ii>=0;)
		iValues[ii].iValue.Close();
	iValues.Close();
	}

void CSqlValues::AddL(const RSqlLiteral& aLiteral)
	{
	TEntry e(aLiteral);
	__DEBUG(e.iType=TDbColType(-1);)
	__LEAVE_IF_ERROR(iValues.Append(e));
	}

void CSqlValues::BindL(const CDbDataSource& aSource)
//
// Bind the values to a column set and optional column name list
//
	{
	iValues.Compress();				// we have finished adding values
	TInt columns=iValues.Count();
	__ASSERT(columns>0);
	if (aSource.ColumnCount()<columns)
		__LEAVE(KErrArgument);		// insert-statement is bad
	for (TInt ii=0;ii<columns;++ii)
		{
		TEntry& e=iValues[ii];
		__ASSERT(e.iType==-1);
		e.iType=aSource.ColumnDef(ii+1).Type();
		if (e.iValue.IsNull())
			continue;
		switch (e.iType)
			{
		default:	// cannot set this kind of column from SQL
			__LEAVE(KErrGeneral);
			break;
		case EDbColBit:
		case EDbColUint8:
		case EDbColUint16:
		case EDbColUint32:
			e.iValue.ToUint32L();
			break;
		case EDbColInt8:
		case EDbColInt16:
		case EDbColInt32:
			e.iValue.ToInt32L();
			break;
		case EDbColInt64:
			e.iValue.ToInt64L();
			break;
		case EDbColReal32:
			e.iValue.ToReal32L();
			break;
		case EDbColReal64:
			e.iValue.ToReal64L();
			break;
		case EDbColDateTime:
			e.iValue.ToTimeL();
			break;
		case EDbColText8:
		case EDbColLongText8:
			e.iValue.ToText8L();
			break;
		case EDbColText16:
		case EDbColLongText16:
			e.iValue.ToText16L();
			break;
		case EDbColBinary:
		case EDbColLongBinary:
			e.iValue.ToBlobL();
			break;
			}
		}
	}

void CSqlValues::WriteL(CDbDataSource& aSource,CDbTable& aTable) const
//
// Set the row buffer with the values
//
	{
	__ASSERT(iValues.Count()>0);
	CDbBlobSpace* blobstore=0;
	TInt columns=iValues.Count();
	for (TInt ii=0;ii<columns;++ii)
		{
		TDbColumn col(aSource.Column(ii+1));
		const TEntry& e=iValues[ii];
		if (TDbCol::IsLong(e.iType))
			{	// check if we need to delete a blob
			if (!blobstore)
				blobstore=aTable.BlobsL();
			__ASSERT(blobstore);
			const TDbBlob& blob=TDbColumnC(col).Blob();
			if (!blob.IsInline())
				blobstore->DeleteL(blob.Id());
			}
		if (e.iValue.IsNull())
			{	// null value
			col.SetNull();
			continue;
			}
		switch (e.iType)
			{
		default:
			__ASSERT(0);
		case EDbColBit:
		case EDbColUint8:
		case EDbColUint16:
		case EDbColUint32:
			col.SetL(e.iValue.Uint32());
			break;
		case EDbColInt8:
		case EDbColInt16:
		case EDbColInt32:
			col.SetL(e.iValue.Int32());
			break;
		case EDbColInt64:
			col.SetL(e.iValue.Int64());
			break;
		case EDbColReal32:
			col.SetL(e.iValue.Real32());
			break;
		case EDbColReal64:
			col.SetL(e.iValue.Real64());
			break;
		case EDbColDateTime:
			col.SetL(e.iValue.Time());
			break;
		case EDbColText8:
			col.SetL(e.iValue.Text8());
			break;
		case EDbColText16:
			col.SetL(e.iValue.Text16());
			break;
		case EDbColLongText8:
			{
			const TDesC8& val=e.iValue.Text8();
			const TUint8* ptr=val.Ptr();
			TInt size=val.Length();
			if (size>blobstore->InlineLimit())
				col.SetBlobL(blobstore->CreateL(EDbColLongText8,ptr,size),size);
			else
				col.SetBlobL(ptr,size);
			}
			break;
		case EDbColLongText16:
			{
			const TDesC16& val=e.iValue.Text16();
			const TUint8* ptr=REINTERPRET_CAST(const TUint8*,val.Ptr());
			TInt size=val.Length()<<1;
			if (size>blobstore->InlineLimit())
				col.SetBlobL(blobstore->CreateL(EDbColLongText16,ptr,size),size);
			else
				col.SetBlobL(ptr,size);
			}
			break;
		case EDbColBinary:
			{
			const TDesC8& val=e.iValue.Blob();
//			const TUint8* ptr=REINTERPRET_CAST(const TUint8*,val.Ptr());
//			TInt size=val.Length();
			col.SetL(val);
//			col.SetBlobL(ptr,size);
			}
			break;
		case EDbColLongBinary:
			{
			const TDesC8& val=e.iValue.Blob();
			const TUint8* ptr=REINTERPRET_CAST(const TUint8*,val.Ptr());
			TInt size=val.Length();
			col.SetBlobL(blobstore->CreateL(EDbColLongBinary,ptr,size),size);
			}
			break;
			}
		}
	}

// Class CSqlDMLStatement

CSqlDMLStatement::~CSqlDMLStatement()
	{
	delete iValues;
	}

CSqlValues& CSqlDMLStatement::ValuesL()
	{
	CSqlValues* v=iValues;
	if (!v)
		iValues=v=new(ELeave) CSqlValues;
	return *v;
	}

// Class CSqlInsertStatement

CSqlInsertStatement* CSqlInsertStatement::NewLC()
	{
	CSqlInsertStatement* self=new(ELeave) CSqlInsertStatement;
	CleanupStack::PushL(self);
	return self;
	}

CDbIncremental* CSqlInsertStatement::ExecuteL(CDbTableDatabase& aDatabase,TDbTextComparison aComparison,TInt& aRows)
//
// Execute an insert-statement. This does not requre incremental work, so return 0
//
	{
	aRows=1;	// 1 row changed after insertion
	CSqlQuery* query=&Query();
	RDbAccessPlan plan(query,aComparison);
	plan.BuildLC(aDatabase,RDbRowSet::EInsertOnly,TDbWindow());
	CDbDataSource& src=plan.Source();
	Values().BindL(src);
	src.NewRowL(KDbNullRecordId);
	RDbTransaction& t=plan.Table().Database().Transaction();
	t.DMLBeginLC();
	Values().WriteL(src,plan.Table());
	src.PrepareToWriteRowL(src.EAppend);
	src.WriteRowL(src.EAppend,src.ENoSynch);
	t.DMLCommitL();
	CleanupStack::Pop();				// transaction complete
	CleanupStack::PopAndDestroy();		// plan
	return 0;	// no incremental work to be done
	}

// Class CDbIncrementalDML

CDbIncrementalDML* CDbIncrementalDML::NewL(CSqlModifyStatement& aStatement,CDbTableDatabase& aDatabase,TDbTextComparison aComparison)
	{
	CSqlQuery* query=&aStatement.Query();
	RDbAccessPlan plan(query,aComparison);
	plan.BuildLC(aDatabase,RDbRowSet::EUpdatable,TDbWindow());
	CDbIncrementalDML* self=new(ELeave) CDbIncrementalDML(plan);
	CleanupStack::PopAndDestroy();	// plan
	if (aStatement.IsUpdate())
		{
		CleanupStack::PushL(self);
		self->iValues=aStatement.AdoptValues();
		self->iValues->BindL(*self->iSource);
		CleanupStack::Pop();	// self
		}
	self->iSource->Reset();
	self->Transaction().DMLBegin();
	self->SetState(EEvaluating);
	return self;
	}

CDbIncrementalDML::~CDbIncrementalDML()
	{
	if (iState!=ECommitted && iState!=EInitialising)
		Transaction().DMLRollback();
	delete iSource;
	delete iValues;
	}

TBool CDbIncrementalDML::NextL(TInt& aRows)
	{
	__ASSERT(iState!=ECommitted);
	if (iState==EFailed)
		__LEAVE(KErrDied);
	TState s=iState;
	iState=EFailed;
	TInt work=256;
	TDbPosition next=EDbNext;
	if (s==EEvaluating)
		{	// evaluate the data source
		TBool atrow=EFalse;
		if (iSource->EvaluateL(work,iRecord,atrow))
			{
			iState=EEvaluating;
			return ETrue;	// more to do
			}
		iRecord=KDbNullRecordId;
		next=EDbFirst;
		s=EUpdating;
		}
	// iterate across the data source
	for (;;)
		{
		if (s==EDeleting)
			{
			Transaction().DMLBeginLC();
			CDbDataSource::TDelete del=iSource->DeleteRowL(iRecord,CDbDataSource::ESynch);
			Transaction().DMLCommitL();
			CleanupStack::Pop();				// transaction complete
			++aRows;
			work-=4;
			switch (del)
				{
			case CDbDataSource::EDeletedAtEnd:
				Transaction().DMLTouch();
				Transaction().DMLCommitL();
				iState=ECommitted;
				return EFalse;
			case CDbDataSource::EDeletedInLimbo:
				s=EUpdating;
			case CDbDataSource::EDeletedAtNext:
				if (work<0)
					{	// exhausted
					iState=s;
					return ETrue;
					}
				}
			}
		else
			{
			switch (iSource->GotoL(work,next,iRecord))
				{
			default:
				__ASSERT(0);
			case CDbDataSource::ESuccess:
				next=EDbNext;
				if (!IsUpdate())
					{
					s=EDeleting;
					break;
					}
				iSource->ReadRowL(iRecord);
				iValues->WriteL(*iSource,iTable);
				iSource->PrepareToWriteRowL(CDbDataSource::EReplace);
				Transaction().DMLBeginLC();
				iSource->WriteRowL(CDbDataSource::EReplace,CDbDataSource::ESynch);
				Transaction().DMLCommitL();
				CleanupStack::Pop();				// transaction complete
				++aRows;
				work-=8;
				break;
			case CDbDataSource::ESynchFailure:
				// dead
				__LEAVE(KErrDied);
			case CDbDataSource::EExhausted:
				// more to do
				iState=EUpdating;
				return ETrue;
			case CDbDataSource::ENoRow:
				// completed the operation!
				Transaction().DMLTouch();
				Transaction().DMLCommitL();
				iState=ECommitted;
				return EFalse;
				}
			}
		}
	}


// Class CSqlModifyStatement

CSqlModifyStatement* CSqlModifyStatement::NewLC()
	{
	CSqlModifyStatement* self=new(ELeave) CSqlModifyStatement;
	CleanupStack::PushL(self);
	return self;
	}

CDbIncremental* CSqlModifyStatement::ExecuteL(CDbTableDatabase& aDatabase,TDbTextComparison aComparison,TInt& aRows)
//
// Execute an update/delete-statement, returning the incremental object that does the work
//
	{
	aRows=0;		// no rows affected initially
	return CDbIncrementalDML::NewL(*this,aDatabase,aComparison);
	}