// Copyright (c) 2005-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 "SqlStatementImpl.h" 	//CSqlStatementImpl

#include "SqlDatabaseImpl.h"	//CSqlDatabaseImpl::Session()

//Constants

_LIT(KSemiColon,";");

_LIT(KTextKWD, 	"TEXT");

_LIT(KCharKWD, 	"CHAR");

_LIT(KClobKWD, 	"CLOB");

_LIT(KBinaryKWD,"BINARY");

_LIT(KBlobKWD,	"BLOB");

_LIT(KRealKWD, 	"REAL");

_LIT(KFloatKWD, "FLOAT");

_LIT(KDoubleKWD,"DOUBLE");

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////             RSqlLongColumnColl        ////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

This "comparison" function is used for searching a particular column value, identified by aIndex, in the long column 

values collection.

@param aIndex An integer pointer to long column index value

@param aData A reference to particular elemt of the long column values collection

@return True of the index of aData item is the same as *aIndex, false otherwise

@panic SqlDb 4 In _DEBUG mode, aIndex is NULL.

@panic SqlDb 4 In _DEBUG mode, *aIndex value is negative.

*/

TBool RSqlLongColumnColl::TData::Compare(const TInt* aIndex, const RSqlLongColumnColl::TData& aData)

	{

	__SQLASSERT(aIndex != NULL, ESqlPanicBadArgument);

	__SQLASSERT(*aIndex >= 0, ESqlPanicBadArgument);

	return *aIndex == aData.iIndex;

	}

/**

Reads a long column value, identified by aColumnIndex parameter, from the server and stores the value in the collection.

@param aReader A RSqlLongColumnColl::TColumnReader object, which performs the "read column value" operation.

@param aColumnIndex Column index

@param aColumnSize The column size in bytes

@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.

@panic SqlDb 4 In _DEBUG mode, aColumnSize is less than KSqlMaxDesLen (not a long column value)

@return KErrNone The call has completed successfully;

		KErrNoMemory Out of memory;

        Note that other system-wide or database specific error codes may also be returned.

*/

TInt RSqlLongColumnColl::Append(RSqlLongColumnColl::TColumnReader& aReader, TInt aColumnIndex, TInt aColumnSize)

	{

	__SQLASSERT(aColumnIndex >= 0, ESqlPanicBadArgument);

	__SQLASSERT(aColumnSize >= KSqlMaxDesLen, ESqlPanicBadArgument);

	LONGCOL_INVARIANT();

	HBufC8* colBuf = HBufC8::New(aColumnSize);

	if(!colBuf)

		{

		return KErrNoMemory;	

		}

	TPtr8 ptr = colBuf->Des();

	TInt err = aReader.Read(aColumnIndex, ptr);

	if(err == KErrNone)

		{

		err = iValues.Append(RSqlLongColumnColl::TData(aColumnIndex, colBuf));	

		}

	if(err != KErrNone)

		{

		delete colBuf;	

		}

	LONGCOL_INVARIANT();

	return err;

	}

#ifdef _DEBUG

/**

RSqlLongColumnColl invariant.

The collection cannot have two column values with the same column index.

The collection cannot have NULL column value, or negative column index.

*/

void RSqlLongColumnColl::Invariant() const

	{

	for(TInt i=iValues.Count()-1;i>=0;--i)

		{

		const RSqlLongColumnColl::TData& data = iValues[i];

		__SQLASSERT(data.iIndex >= 0, ESqlPanicInternalError);

		__SQLASSERT(data.iData != NULL, ESqlPanicInternalError);

		for(TInt j=i-1;j>=0;--j)

			{

			__SQLASSERT(data.iIndex != iValues[j].iIndex, ESqlPanicInternalError);

			}

		}

	}

#endif

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////           CSqlStatementImpl           ////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

RSqlLongColumnColl::TColumnReader derived class, which implements the pure virtual RSqlLongColumnColl::TColumnReader::Read().

The class is used for retrieving long column values from the server.

@internalComponent

*/

NONSHARABLE_STRUCT(TSqlLongColumnReader) : public RSqlLongColumnColl::TColumnReader

	{

	TSqlLongColumnReader(RSqlStatementSession& aStmtSession) :

		iStmtSession(aStmtSession)

		{

		}

	virtual TInt Read(TInt aColumnIndex, TDes8& aBuf)

		{

		return iStmtSession.ReadColumnValue(aColumnIndex, aBuf);

		}

	RSqlStatementSession	iStmtSession;

	};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////           CSqlStatementImpl           ////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Frees the allocated memory and other resources.

*/

CSqlStatementImpl::~CSqlStatementImpl()

	{

	iDeclaredColumnTypes.Close();

	iLongColumnColl.Close();

	iParamValueBuf.Close();

	iParamNameBuf.Close();

	iColumnValueBuf.Close();

	iColumnNameBuf.Close();

	iSqlStmtSession.Close();

	}

/**

Resets the prepared SQL statement back to its initial state and makes it ready for re-execution.

The parameters of the SQL statement retain their values.

If CSqlStatementImpl object processes parametrized SQL statement, the parameter values can be bound after 

the Reset() call.

The method sets the internal object's state to CSqlStatementImpl::EUnknown. The column data accessors

cannot be used until the next successful Next() call.

@return KSqlErrStmtExpired, statement expired (if new functions or collating sequences are 

							registered or if an authorizer function is added or changed);

		KErrNone, the operation has completed successfully.

@see RSqlStatement::Reset()

*/

TInt CSqlStatementImpl::Reset()

	{

	iState = CSqlStatementImpl::EUnknown;

	iLongColumnColl.Reset();

	if(iParamCnt > 0)

		{

		iParamValueBuf.ResetAndMinimize();

		}

	return iSqlStmtSession.Reset();

	}

/**

Executes the prepared DDL/DML SQL statement. 

If the SQL statement contains parameters, their values will be bound right before the execution.

The method sets the internal object's state to CSqlStatementImpl::EUnknown. The column data accessors

cannot be used until the next successful Next() call.

@return >=0, The operation has completed successfully. The number of database rows that were 

			 changed/inserted/deleted by the most recently completed DDL/DML sql statement.

			 Exception: If the executed statement is "DELETE FROM <table>", then the function returns 0 

			 if the operation has completed successfully (disregarding the number of the deleted rows);

	    KSqlErrStmtExpired, statement has expired (if new functions or collating sequences are 

							registered or if an authorizer function is added or changed);

		KErrNoMemory, an out of memory condition has occurred.

                      Note that database specific errors categorised as ESqlDbError, and

                      other system-wide error codes may also be returned.

@see RSqlStatement::Exec()

*/

TInt CSqlStatementImpl::Exec()

	{

	iState = CSqlStatementImpl::EUnknown;

	TInt rc = 0;

	if(iBound)

		{

		rc = iSqlStmtSession.Exec();	

		}

	else

		{

		rc = iSqlStmtSession.BindExec(iParamValueBuf);

		iBound = ETrue;

		iParamValueBuf.ResetAndMinimize();

		}

	return rc;

	}

/**

Executes the prepared DDL/DML SQL statement asynchronously. 

If the SQL statement contains parameters, their values will be bound right before the execution.

The method sets the internal object's state to CSqlStatementImpl::EUnknown. The column data accessors

cannot be used until the next successful Next() call.

@param aStatus Completion status of asynchronous request, one of the following:

		 >=0, The operation has completed successfully. The number of database rows that were 

		   	   changed/inserted/deleted by the most recently completed DDL/DML sql statement.

			 Exception: If the executed statement is "DELETE FROM <table>", then the function returns 0 

			 if the operation has completed successfully (disregarding the number of the deleted rows);

         KSqlErrStmtExpired, the SQL statement has expired (if new functions or

                            collating sequences have been registered or if an

                            authorizer function has been added or changed);

         KErrNoMemory, an out of memory condition has occurred - the statement

                      will be reset.

                      Note that aStatus may be set with database specific errors categorised as ESqlDbError, 

                      and other system-wide error codes.

@see RSqlStatement::Exec()

*/

void CSqlStatementImpl::Exec(TRequestStatus& aStatus)

	{

	iState = CSqlStatementImpl::EUnknown;

	if(iBound)

		{

		iSqlStmtSession.Exec(aStatus);

		}

	else

		{

		iSqlStmtSession.BindExec(iParamValueBuf, aStatus);

		iBound = ETrue;

		//Here: it is not possible to reset iParamValueBuf for "safety", because this is an asynchronous call

		//      and the buffer content has to be preserved until the operation completes.

		}

	}

/**

Retrieves a record.

If the prepared SQL statement is a "SELECT" statement, and is expected to

return a set of records, then this function can be used to retrieve that record data.

If the SQL statement contains parameters, then their values must be bound before

this function is called.

If the call to this function completes successfully, i.e. it returns

with KSqlAtRow, then this CSqlStatementImpl object contains the record data, and 

this data will remain valid for access until another call is made to any

CSqlStatementImpl function.

The record data can be accessed using the following functions:

- CSqlStatementImpl::ColumnType()

- CSqlStatementImpl::ColumnSize()

- CSqlStatementImpl::Column<Type>()

@return KSqlAtRow,      the record data is ready for processing by the caller;

        KSqlAtEnd,      there is no more record data;

        KSqlErrBusy,    the database file is locked;

        KErrNoMemory,   an out of memory condition has occurred - the statement

                        will be reset;

        KSqlErrGeneral, a run-time error has occured - this function must not

                        be called again;        

        KSqlErrMisuse,  this function has been called after a previous call

                        returned KSqlAtEnd or KSqlErrGeneral.

        KSqlErrStmtExpired, the SQL statement has expired (if new functions or

                            collating sequences have been registered or if an

                            authorizer function has been added or changed);

@see RSqlStatement::Next()

*/

TInt CSqlStatementImpl::Next()

	{

	iLongColumnColl.Reset();

	iColumnValueBuf.ResetAndMinimize();

	iState = CSqlStatementImpl::EUnknown;

	TInt err = KErrNone;

	if(iBound)

		{

		err = iSqlStmtSession.Next(iColumnValueBuf);

		}

	else

		{

		err = iSqlStmtSession.BindNext(iParamValueBuf, iColumnValueBuf);

		iBound = ETrue;

		iParamValueBuf.ResetAndMinimize();

		}

	iColumnValBufIt.Set(iColumnValueBuf);

	if(err == KSqlAtRow)

		{

		iState = CSqlStatementImpl::EAtRow;

		}

	return err;

	}

/**

Implements RSqlStatement::BindNull().

@panic SqlDb 5 Parameter index out of bounds.

@see RSqlStatement::BindNull()

*/	

TInt CSqlStatementImpl::BindNull(TInt aParamIndex)

	{

	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);

	iBound = EFalse;

	iParamValBufIt.MoveTo(aParamIndex);

	iParamValBufIt.SetNull();

	return KErrNone;

	}

/**

Implements RSqlStatement::BindInt().

@panic SqlDb 5 Parameter index out of bounds.

@see RSqlStatement::BindInt()

*/	

TInt CSqlStatementImpl::BindInt(TInt aParamIndex, TInt aParamValue)

	{

	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);

	iBound = EFalse;

	iParamValBufIt.MoveTo(aParamIndex);

	return iParamValBufIt.SetInt(aParamValue);

	}

/**

Implements RSqlStatement::BindInt64().

@panic SqlDb 5 Parameter index out of bounds.

@see RSqlStatement::BindInt64()

*/	

TInt CSqlStatementImpl::BindInt64(TInt aParamIndex, TInt64 aParamValue)

	{

	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);

	iBound = EFalse;

	iParamValBufIt.MoveTo(aParamIndex);

	return iParamValBufIt.SetInt64(aParamValue);

	}

/**

Implements RSqlStatement::BindReal().

@panic SqlDb 5 Parameter index out of bounds.

@see RSqlStatement::BindReal()

*/	

TInt CSqlStatementImpl::BindReal(TInt aParamIndex, TReal aParamValue)

	{

	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);

	iBound = EFalse;

	iParamValBufIt.MoveTo(aParamIndex);

	return iParamValBufIt.SetReal(aParamValue);

	}

/**

Implements RSqlStatement::BindText().

@panic SqlDb 5 Parameter index out of bounds.

@see RSqlStatement::BindText()

*/	

TInt CSqlStatementImpl::BindText(TInt aParamIndex, const TDesC& aParamText)

	{

	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);

	iBound = EFalse;

	iParamValBufIt.MoveTo(aParamIndex);

	return iParamValBufIt.SetText(aParamText);

	}

/**

Implements RSqlStatement::BindBinary().

@panic SqlDb 5 Parameter index out of bounds.

@see RSqlStatement::BindBinary()

*/	

TInt CSqlStatementImpl::BindBinary(TInt aParamIndex, const TDesC8& aParamData)

	{

	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);

	iBound = EFalse;

	iParamValBufIt.MoveTo(aParamIndex);

	return iParamValBufIt.SetBinary(aParamData);

	}

/**

Implements RSqlStatement::BindZeroBlob().

@panic SqlDb 5 Parameter index out of bounds.

@see RSqlStatement::BindZeroBlob()

*/	

TInt CSqlStatementImpl::BindZeroBlob(TInt aParamIndex, TInt aBlobSize)

	{

	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);

	iBound = EFalse;

	iParamValBufIt.MoveTo(aParamIndex);

	return iParamValBufIt.SetZeroBlob(aBlobSize);

	}

/**

Implements RSqlStatement::ColumnType().

@panic SqlDb 5 Column index out of bounds.

@panic SqlDb 11 Statement cursor not positioned on a row.

@see RSqlStatement::ColumnType().

*/	

TSqlColumnType CSqlStatementImpl::ColumnType(TInt aColumnIndex)

	{

	__SQLASSERT_ALWAYS((TUint)aColumnIndex < (TUint)iColumnCnt, ESqlPanicBadColumnIndex);

	__SQLASSERT_ALWAYS(iState == CSqlStatementImpl::EAtRow, ESqlPanicInvalidRow);

	iColumnValBufIt.MoveTo(aColumnIndex);		

	return static_cast <TSqlColumnType> (iColumnValBufIt.Type());

	}

/**

Implements RSqlStatement::DeclaredColumnType().

@param aColumnIndex The index value identifying the column. This is 0 for the first column.

@param aColumnType	Output parameter. Upon completion this will contain the type of the column.

@return KErrNone, the operation completed successfully;

        KErrNoMemory, an out of memory condition has occurred.

                  One of the other system-wide error codes may also be returned.

@panic SqlDb 5 Column index out of bounds.

@see RSqlStatement::DeclaredColumnType().

*/

TInt CSqlStatementImpl::DeclaredColumnType(TInt aColumnIndex, TSqlColumnType& aColumnType)

	{

	__SQLASSERT_ALWAYS((TUint)aColumnIndex < (TUint)iColumnCnt, ESqlPanicBadColumnIndex);

	if(iDeclaredColumnTypes.Count() == 0 && iColumnCnt > 0) //initialise iDeclaredColumnTypes array if necessary

		{

		TInt err = iDeclaredColumnTypes.Reserve(iColumnCnt);//We know what the array size should be - iColumnCnt

		if(err != KErrNone)

			{

			return err;

			}

		HBufC* colTypeNamesBuf = NULL;//Buffer for declared column type names, delimited by ';'.

		TRAP(err, colTypeNamesBuf = GetDeclColumnTypesL());

		if(err != KErrNone)

			{

			__SQLASSERT(!colTypeNamesBuf, ESqlPanicInternalError);

			iDeclaredColumnTypes.Reset();

			return err;	

			}

		//Iterate over the column type names and map each column type name to one of the TSqlColumnType enum item values.

		//No error can occur from here till the end of the function code.

		__SQLASSERT(colTypeNamesBuf != NULL, ESqlPanicInternalError);

		TPtrC colTypeNames(*colTypeNamesBuf);

		TInt colIdx = 0;

		while(colTypeNames.Length() > 0)

			{

			TInt pos = colTypeNames.Find(KSemiColon);

			if(pos < 0)

				{

				break;

				}

			TPtrC colTypeName(colTypeNames.Ptr(), pos);

			if(pos == colTypeNames.Length() - 1)

				{

				colTypeNames.Set(NULL, 0);	

				}

			else

				{

				colTypeNames.Set(colTypeNames.Ptr() + pos + 1, colTypeNames.Length() - (pos + 1));

				}

			TSqlColumnType colType = ESqlInt;

			if(colTypeName.FindF(KCharKWD) >= 0 || colTypeName.FindF(KTextKWD) >= 0 || colTypeName.FindF(KClobKWD) >= 0)

				{

				colType = ESqlText;

				}

			else if(colTypeName.FindF(KBinaryKWD) >= 0 || colTypeName.FindF(KBlobKWD) >= 0)

				{

				colType = ESqlBinary;

				}

			else if(colTypeName.FindF(KRealKWD) >= 0 || colTypeName.FindF(KFloatKWD) >= 0 || colTypeName.FindF(KDoubleKWD) >= 0)

				{

				colType = ESqlReal;

				}

			err = iDeclaredColumnTypes.Append(colType);

			__SQLASSERT(err == KErrNone, ESqlPanicInternalError);//memory for the array elements has been reserved already

			++colIdx;

			}//end of - while(colTypeNames.Length() > 0)

		__SQLASSERT(colIdx == iColumnCnt, ESqlPanicInternalError);

		delete colTypeNamesBuf;

		}//end of - if(iDeclaredColumnTypes.Count() == 0 && iColumnCnt > 0)

	aColumnType = iDeclaredColumnTypes[aColumnIndex];

	return KErrNone;

	}

/**

Implements RSqlStatement::ColumnSize().

@panic SqlDb 5 Column index out of bounds.

@panic SqlDb 11 Statement cursor not positioned on a row

@see RSqlStatement::ColumnSize().

*/	

TInt CSqlStatementImpl::ColumnSize(TInt aColumnIndex)

	{

	__SQLASSERT_ALWAYS((TUint)aColumnIndex < (TUint)iColumnCnt, ESqlPanicBadColumnIndex);

	__SQLASSERT_ALWAYS(iState == CSqlStatementImpl::EAtRow, ESqlPanicInvalidRow);

	iColumnValBufIt.MoveTo(aColumnIndex);		

	return iColumnValBufIt.Size();

	}

/**