diff -r 000000000000 -r 08ec8eefde2f persistentstorage/sql/SRC/Client/SqlStatementImpl.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/sql/SRC/Client/SqlStatementImpl.inl	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,383 @@
+// Copyright (c) 2006-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:
+// ///////////////////////             RSqlLongColumnColl        ////////////////////////////////////////////
+// Sets the default granularity of the collection.
+// 
+//
+
+inline RSqlLongColumnColl::RSqlLongColumnColl() :
+	iValues(KLongColumnCollGranularity)
+	{
+	}
+
+/**
+Releases the allocated memory.
+*/
+inline void RSqlLongColumnColl::Close()
+	{
+	LONGCOL_INVARIANT();
+	Reset();
+	iValues.Close();	
+	}
+
+/**
+Destroys all long column values in the collection, without destroying the collection object.
+*/
+inline void RSqlLongColumnColl::Reset()
+	{
+	LONGCOL_INVARIANT();
+	for(TInt i=iValues.Count()-1;i>=0;--i)
+		{
+		delete iValues[i].iData;
+		}
+	iValues.Reset();
+	}
+
+/**
+Constructs and returns a TPtrC object to the long column value, identified by aColumnIndex argument.
+@param aColumnIndex Column index
+@return A TPtrC object to the long column value
+@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
+@panic SqlDb 7 There is no long column value with aColumnIndex index.
+*/
+inline TPtrC RSqlLongColumnColl::Text(TInt aColumnIndex) const
+	{
+	__SQLASSERT(aColumnIndex >= 0, ESqlPanicBadArgument);
+	LONGCOL_INVARIANT();
+	TInt rc = FindValue(aColumnIndex);
+	__SQLASSERT_ALWAYS(rc >= 0, ESqlPanicInternalError);
+	TPtrC8 ptr(iValues[rc].iData->Des());
+	return TPtrC(reinterpret_cast <const TUint16*> (ptr.Ptr()), ptr.Length() / sizeof(TUint16));
+	}
+
+/**
+Constructs and returns a TPtrC8 object to the long column value, identified by aColumnIndex argument.
+@param aColumnIndex Column index
+@return A TPtrC8 object to the long column value
+@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
+@panic SqlDb 7 There is no long column value with aColumnIndex index.
+*/
+inline TPtrC8 RSqlLongColumnColl::Binary(TInt aColumnIndex) const
+	{
+	__SQLASSERT(aColumnIndex >= 0, ESqlPanicBadArgument);
+	LONGCOL_INVARIANT();
+	TInt rc = FindValue(aColumnIndex);
+	__SQLASSERT_ALWAYS(rc >= 0, ESqlPanicInternalError);
+	return iValues[rc].iData->Des();
+	}
+
+/**
+Returns true if there is a long column value in the collection, which index is aColumnIndex.
+@param aColumnIndex Column index
+@return True if there is a long column value in the collection, which index is aColumnIndex.
+@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
+*/
+inline TBool RSqlLongColumnColl::IsPresent(TInt aColumnIndex) const
+	{
+	__SQLASSERT(aColumnIndex >= 0, ESqlPanicBadArgument);
+	LONGCOL_INVARIANT();
+	return FindValue(aColumnIndex) >= 0;
+	}
+
+/**
+The method returns the index in the collection of the long column value, identified by aColumnIndex argument.
+@param aColumnIndex Column index
+@return The collection index of the long column value, identified by aColumnIndex,
+		KErrNotFound otherwise.
+@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
+*/
+inline TInt RSqlLongColumnColl::FindValue(TInt aColumnIndex) const
+	{
+	__SQLASSERT(aColumnIndex >= 0, ESqlPanicBadArgument);
+	return iValues.Find(aColumnIndex, &RSqlLongColumnColl::TData::Compare);
+	}
+
+/**
+Initializes the RSqlLongColumnColl::TData instance with the column index, and a pointer to the column data
+@param aIndex Column index
+@param aData A HBufC8 pointer to the column data. Cannot be NULL, this is a long column value
+@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative or aData is NULL.
+*/
+inline RSqlLongColumnColl::TData::TData(TInt aIndex, HBufC8* aData) :
+	iIndex(aIndex),
+	iData(aData)
+	{
+	__SQLASSERT(aIndex >= 0, ESqlPanicBadArgument);
+	__SQLASSERT(aData != NULL, ESqlPanicBadArgument);
+	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////           CSqlStatementImpl           ////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	
+/**
+Initializes the created CSqlDatabaseImpl object.
+Works with 8/16-bit SQL statements.
+
+@param aDatabase A reference to CSqlDatabaseImpl object.
+@param aSqlStmt 8/16-bit string containing the SQL statement.
+
+@return KErrNoMemory, an out of memory condition has occurred;
+ 	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
+                      Note that the function may leave with some database specific errors categorised as 
+                      ESqlDbError or other system-wide error codes;
+        KErrNone      Operation has completed successfully.
+
+@see CSqlStatementImpl::New()
+*/
+template <class DES> TInt CSqlStatementImpl::Construct(CSqlDatabaseImpl& aDatabase, const DES& aSqlStmt)
+	{
+	TInt err = iSqlStmtSession.Prepare(aDatabase.Session(), aSqlStmt, iColumnCnt, iParamCnt);
+	if(err != KErrNone)
+		{
+		return err;	
+		}
+	if(iColumnCnt >= 0)
+		{
+		err = iColumnValueBuf.SetCount(iColumnCnt);
+		if(err != KErrNone)
+			{
+			return err;	
+			}
+		iColumnValBufIt.Set(iColumnValueBuf);
+		}
+	if(iParamCnt > 0)
+		{
+		err = iParamValueBuf.SetCount(iParamCnt);
+		if(err != KErrNone)
+			{
+			return err;	
+			}
+		iParamValBufIt.Set(iParamValueBuf);
+		}
+	return KErrNone;
+	}
+
+/**
+Template function, friend of CSqlStatementImpl, that is used for creation of CSqlStatementImpl objects.
+
+@param aImpl A reference to a CSqlStatementImpl pointer. Will be initialized after a successfull CSqlStatementImpl construction.
+@param aDatabase A reference to a CSqlDatabaseImpl object.
+@param aSqlStmt The SQL statement: 8-bit or 16-bit.
+
+@return KErrNoMemory, an out of memory condition has occurred;
+ 	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
+                      Note that the function may leave with some database specific errors categorised as 
+                      ESqlDbError or other system-wide error codes;
+        KErrNone      Operation has completed successfully.
+
+@internalComponent
+*/
+template <class DES> TInt SqlCreateStatement(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const DES& aSqlStmt)
+	{
+	TInt err = KErrNoMemory;
+	aImpl = new CSqlStatementImpl;
+	if(aImpl)
+		{
+		err = aImpl->Construct(aDatabase, aSqlStmt);
+		}
+	if(err != KErrNone)
+		{
+		delete aImpl;
+		aImpl = NULL;
+		}
+	return err;
+	}
+
+/**
+Factory function for creating CSqlStatementImpl objects.
+Works with 16-bit SQL statements.
+
+Creates CSqlStatementImpl instance and prepares the supplied SQL statement for execution.
+
+Note that:
+- CSqlStatementImpl can prepare and execute both parametrized SQL statements and SQL statements 
+  without parameters;
+- CSqlStatementImpl cannot prepare and execute SQL strings containing more than one SQL statement;
+
+@param aImpl A reference to CSqlStatementImpl pointer which will be set to point to the created instance
+@param aDatabase A reference to CSqlDatabaseImpl object.
+@param aSqlStmt 16-bit string containing the SQL statement.
+
+@return KErrNoMemory, an out of memory condition has occurred;
+ 	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
+                      Note that the function may leave with some database specific errors categorised as 
+                      ESqlDbError or other system-wide error codes;
+        KErrNone      Operation has completed successfully.
+
+@see RSqlStatement
+@see RSqlStatement::Prepare()
+*/
+inline TInt CSqlStatementImpl::New(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const TDesC16& aSqlStmt)
+	{
+	return SqlCreateStatement(aImpl, aDatabase, aSqlStmt);
+	}
+
+/**
+Factory function for creating CSqlStatementImpl objects.
+Works with 8-bit SQL statements.
+
+Creates CSqlStatementImpl instance and prepares the supplied SQL statement for execution.
+
+Note that:
+- CSqlStatementImpl can prepare and execute both parametrized SQL statements and SQL statements 
+  without parameters;
+- CSqlStatementImpl cannot prepare and execute SQL strings containing more than one SQL statement;
+
+@param aImpl A reference to CSqlStatementImpl pointer which will be set to point to the created instance
+@param aDatabase A reference to CSqlDatabaseImpl object.
+@param aSqlStmt 8-bit string containing the SQL statement.
+
+@return KErrNoMemory, an out of memory condition has occurred;
+ 	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
+                      Note that the function may leave with some database specific errors categorised as 
+                      ESqlDbError or other system-wide error codes;
+        KErrNone      Operation has completed successfully.
+
+@see RSqlStatement
+@see RSqlStatement::Prepare()
+*/
+inline TInt CSqlStatementImpl::New(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const TDesC8& aSqlStmt)
+	{
+	return SqlCreateStatement(aImpl, aDatabase, aSqlStmt);
+	}
+
+/**
+@return Non-zero if CSqlStatementImpl object points at a valid record, zero otherwise.
+
+@see RSqlStatement::AtRow()
+*/
+inline TBool CSqlStatementImpl::AtRow() const
+	{
+	return iState == CSqlStatementImpl::EAtRow;
+	}
+
+/**
+Implements RSqlStatement::ColumnCount().
+
+@see RSqlStatement::ColumnCount().
+
+@return The column count of the statement
+*/	
+inline TInt CSqlStatementImpl::ColumnCount() const
+	{
+	return iColumnCnt;
+	}
+
+/**
+Gets the index (starting from 0) of the parameter with the given name.
+
+The function does a case insensitive parameter name search.
+
+If the parameter name is ":Prm", then the ":" prefix cannot be omitted when you call ParameterIndex().
+
+This function can be called at any time after the SQL statement has been prepared.
+
+@param aParamName Parameter name
+
+@return the parameter index value, if successful - this is a non-negative integer value;
+        KErrNotFound, if no such parameter can be found.
+        One of the other system-wide error codes may also be returned.
+
+@see RSqlStatement::ParamIndex()
+*/
+inline TInt CSqlStatementImpl::ParamIndex(const TDesC& aParamName)
+	{
+	return Name2Index(aParamName, iParamNameBuf, iParamCnt, ESqlSrvStmtParamNames, iParamNameBufPresent);
+	}
+
+/**
+Gets the index (starting from 0) of the column with the given name.
+
+The function does a case insensitive column name search.
+
+This function can be called at any time after the SQL statement has been prepared.
+
+@param aColumnName Column name
+
+@return the column index value, if successful - this is a non-negative integer value;
+        KErrNotFound, if no such parameter can be found.
+        One of the other system-wide error codes may also be returned.
+
+@see RSqlStatement::ColumnIndex()
+*/
+inline TInt CSqlStatementImpl::ColumnIndex(const TDesC& aColumnName)
+	{
+	return Name2Index(aColumnName, iColumnNameBuf, iColumnCnt, ESqlSrvStmtColumnNames, iColumnNameBufPresent);
+	}
+
+/**
+Gives an access to the content of the requested column as a stream of bytes or characters.
+
+The method creates a read-only MStreamBuf derived object which allows the column with aColumnIndex index 
+to be accessed as a stream of bytes (if the column is a binary column) or characters 
+(if the column is a text column) and returns it to the caller.
+
+The caller is responsible for the destroying of the read-only MStreamBuf derived object.
+
+ColumnSourceL() can be used only after successful Next() call (Next() returned KSqlAtRow),
+otherwise the method issues panic 11.
+
+@param aColumnIndex Column index (starting from 0)
+@return A pointer to the created read-only memory MStreamBuf derived object.
+
+@leave KErrNoMemory, an out of memory condition has occurred;
+
+@panic SqlDb  5 Column index out of bounds.
+@panic SqlDb  7 In _DEBUG mode. aColumnIndex index does not refer to a text or binary column.
+@panic SqlDb 11 Statement object not positioned at row.
+
+@see RSqlColumnReadStream
+*/
+inline MStreamBuf* CSqlStatementImpl::ColumnSourceL(TInt aColumnIndex)
+	{
+	__SQLASSERT_ALWAYS((TUint)aColumnIndex < (TUint)iColumnCnt, ESqlPanicBadColumnIndex);
+	__SQLASSERT_ALWAYS(iState == CSqlStatementImpl::EAtRow, ESqlPanicInvalidRow);
+	iColumnValBufIt.MoveTo(aColumnIndex);		
+	return iColumnValBufIt.IsPresent() ? iColumnValBufIt.StreamL() : iSqlStmtSession.ColumnSourceL(aColumnIndex);
+	}
+
+/**
+Gives an access to the content of the requested parameter as a stream of bytes or characters.
+
+The method creates an IPC object with buffering capabilities, allowing to stream out the data of the 
+parameter with aParameterIndex index and returns this MStreamBuf derived object to the caller.
+
+The caller is responsible for the destroying of the MStreamBuf derived object.
+
+@param aFunction Requested operation
+@param aParamIndex Parameter index (starting from 0)
+
+@return A pointer to the created MStreamBuf derived object.
+
+@leave KErrNoMemory, an out of memory condition has occurred;
+
+@panic SqlDb 5 Parameter index out of bounds.
+
+@see RSqlParamWriteStream
+*/
+inline MStreamBuf* CSqlStatementImpl::ParamSinkL(TSqlSrvFunction aFunction, TInt aParamIndex)
+	{
+	__SQLASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, ESqlPanicBadColumnIndex);
+	return iSqlStmtSession.ParamSinkL(aFunction, aParamIndex);
+	}
+
+/**
+Sets the internal state of CSqlStatementImpl instance to CSqlStatementImpl::EUnknown.
+*/
+inline CSqlStatementImpl::CSqlStatementImpl() :
+	iBound(ETrue),
+	iState(CSqlStatementImpl::EUnknown)
+	{
+	}