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