Symaptic: os/persistentdata/persistentstorage/sql/SRC/Client/SqlStatementImpl.inl@260cb5ec6c19

     1 // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // ///////////////////////             RSqlLongColumnColl        ////////////////////////////////////////////

    15 // Sets the default granularity of the collection.

    16 //

    17 //

    19 inline RSqlLongColumnColl::RSqlLongColumnColl() :

    20 	iValues(KLongColumnCollGranularity)

    21 	{

    22 	}

    24 /**

    25 Releases the allocated memory.

    26 */

    27 inline void RSqlLongColumnColl::Close()

    28 	{

    29 	LONGCOL_INVARIANT();

    30 	Reset();

    31 	iValues.Close();

    32 	}

    34 /**

    35 Destroys all long column values in the collection, without destroying the collection object.

    36 */

    37 inline void RSqlLongColumnColl::Reset()

    38 	{

    39 	LONGCOL_INVARIANT();

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

    41 		{

    42 		delete iValues[i].iData;

    43 		}

    44 	iValues.Reset();

    45 	}

    47 /**

    48 Constructs and returns a TPtrC object to the long column value, identified by aColumnIndex argument.

    49 @param aColumnIndex Column index

    50 @return A TPtrC object to the long column value

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

    52 @panic SqlDb 7 There is no long column value with aColumnIndex index.

    53 */

    54 inline TPtrC RSqlLongColumnColl::Text(TInt aColumnIndex) const

    55 	{

    56 	__ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));

    57 	LONGCOL_INVARIANT();

    58 	TInt rc = FindValue(aColumnIndex);

    59 	__ASSERT_ALWAYS(rc >= 0, __SQLPANIC(ESqlPanicInternalError));

    60 	TPtrC8 ptr(iValues[rc].iData->Des());

    61 	return TPtrC(reinterpret_cast <const TUint16*> (ptr.Ptr()), ptr.Length() / sizeof(TUint16));

    62 	}

    64 /**

    65 Constructs and returns a TPtrC8 object to the long column value, identified by aColumnIndex argument.

    66 @param aColumnIndex Column index

    67 @return A TPtrC8 object to the long column value

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

    69 @panic SqlDb 7 There is no long column value with aColumnIndex index.

    70 */

    71 inline TPtrC8 RSqlLongColumnColl::Binary(TInt aColumnIndex) const

    72 	{

    73 	__ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));

    74 	LONGCOL_INVARIANT();

    75 	TInt rc = FindValue(aColumnIndex);

    76 	__ASSERT_ALWAYS(rc >= 0, __SQLPANIC(ESqlPanicInternalError));

    77 	return iValues[rc].iData->Des();

    78 	}

    80 /**

    81 Returns true if there is a long column value in the collection, which index is aColumnIndex.

    82 @param aColumnIndex Column index

    83 @return True if there is a long column value in the collection, which index is aColumnIndex.

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

    85 */

    86 inline TBool RSqlLongColumnColl::IsPresent(TInt aColumnIndex) const

    87 	{

    88 	__ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));

    89 	LONGCOL_INVARIANT();

    90 	return FindValue(aColumnIndex) >= 0;

    91 	}

    93 /**

    94 The method returns the index in the collection of the long column value, identified by aColumnIndex argument.

    95 @param aColumnIndex Column index

    96 @return The collection index of the long column value, identified by aColumnIndex,

    97 		KErrNotFound otherwise.

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

    99 */

   100 inline TInt RSqlLongColumnColl::FindValue(TInt aColumnIndex) const

   101 	{

   102 	__ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));

   103 	return iValues.Find(aColumnIndex, &RSqlLongColumnColl::TData::Compare);

   104 	}

   106 /**

   107 Initializes the RSqlLongColumnColl::TData instance with the column index, and a pointer to the column data

   108 @param aIndex Column index

   109 @param aData A HBufC8 pointer to the column data. Cannot be NULL, this is a long column value

   110 @panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative or aData is NULL.

   111 */

   112 inline RSqlLongColumnColl::TData::TData(TInt aIndex, HBufC8* aData) :

   113 	iIndex(aIndex),

   114 	iData(aData)

   115 	{

   116 	__ASSERT_DEBUG(aIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));

   117 	__ASSERT_DEBUG(aData != NULL, __SQLPANIC(ESqlPanicBadArgument));

   118 	}

   120 /////////////////////////////////////////////////////////////////////////////////////////////////////////////

   121 //////////////////////////           CSqlStatementImpl           ////////////////////////////////////////////

   122 /////////////////////////////////////////////////////////////////////////////////////////////////////////////

   124 /**

   125 Initializes the created CSqlDatabaseImpl object.

   126 Works with 8/16-bit SQL statements.

   128 @param aDatabase A reference to CSqlDatabaseImpl object.

   129 @param aSqlStmt 8/16-bit string containing the SQL statement.

   131 @return KErrNoMemory, an out of memory condition has occurred;

   132  	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.

   133                       Note that the function may leave with some database specific errors categorised as

   134                       ESqlDbError or other system-wide error codes;

   135         KErrNone      Operation has completed successfully.

   137 @panic SqlDb 7 In _DEBUG mode, invalid column count.

   139 @see CSqlStatementImpl::New()

   140 */

   141 template <class DES> TInt CSqlStatementImpl::Construct(CSqlDatabaseImpl& aDatabase, const DES& aSqlStmt)

   142 	{

   143 	TInt err = iSqlStmtSession.Prepare(aDatabase.Session(), aSqlStmt, iColumnCnt, iParamCnt);

   144 	if(err != KErrNone)

   145 		{

   146 		return err;

   147 		}

   148 	__ASSERT_DEBUG(iColumnCnt >= 0, __SQLPANIC(ESqlPanicInternalError));

   149     err = iColumnValueBuf.SetCount(iColumnCnt);

   150     if(err != KErrNone)

   151         {

   152         return err;

   153         }

   154     iColumnValBufIt.Set(iColumnValueBuf);

   155 	if(iParamCnt > 0)

   156 		{

   157 		err = iParamValueBuf.SetCount(iParamCnt);

   158 		if(err != KErrNone)

   159 			{

   160 			return err;

   161 			}

   162 		iParamValBufIt.Set(iParamValueBuf);

   163 		}

   164 	return KErrNone;

   165 	}

   167 /**

   168 Template function, friend of CSqlStatementImpl, that is used for creation of CSqlStatementImpl objects.

   170 @param aImpl A reference to a CSqlStatementImpl pointer. Will be initialized after a successfull CSqlStatementImpl construction.

   171 @param aDatabase A reference to a CSqlDatabaseImpl object.

   172 @param aSqlStmt The SQL statement: 8-bit or 16-bit.

   174 @return KErrNoMemory, an out of memory condition has occurred;

   175  	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.

   176                       Note that the function may leave with some database specific errors categorised as

   177                       ESqlDbError or other system-wide error codes;

   178         KErrNone      Operation has completed successfully.

   180 @internalComponent

   181 */

   182 template <class DES> TInt SqlCreateStatement(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const DES& aSqlStmt)

   183 	{

   184 	TInt err = KErrNoMemory;

   185 	aImpl = new CSqlStatementImpl;

   186 	if(aImpl)

   187 		{

   188 		err = aImpl->Construct(aDatabase, aSqlStmt);

   189 		}

   190 	if(err != KErrNone)

   191 		{

   192 		delete aImpl;

   193 		aImpl = NULL;

   194 		}

   195 	return err;

   196 	}

   198 /**

   199 Factory function for creating CSqlStatementImpl objects.

   200 Works with 16-bit SQL statements.

   202 Creates CSqlStatementImpl instance and prepares the supplied SQL statement for execution.

   204 Note that:

   205 - CSqlStatementImpl can prepare and execute both parametrized SQL statements and SQL statements

   206   without parameters;

   207 - CSqlStatementImpl cannot prepare and execute SQL strings containing more than one SQL statement;

   209 @param aImpl A reference to CSqlStatementImpl pointer which will be set to point to the created instance

   210 @param aDatabase A reference to CSqlDatabaseImpl object.

   211 @param aSqlStmt 16-bit string containing the SQL statement.

   213 @return KErrNoMemory, an out of memory condition has occurred;

   214  	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.

   215                       Note that the function may leave with some database specific errors categorised as

   216                       ESqlDbError or other system-wide error codes;

   217         KErrNone      Operation has completed successfully.

   219 @see RSqlStatement

   220 @see RSqlStatement::Prepare()

   221 */

   222 inline TInt CSqlStatementImpl::New(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const TDesC16& aSqlStmt)

   223 	{

   224 	return SqlCreateStatement(aImpl, aDatabase, aSqlStmt);

   225 	}

   227 /**

   228 Factory function for creating CSqlStatementImpl objects.

   229 Works with 8-bit SQL statements.

   231 Creates CSqlStatementImpl instance and prepares the supplied SQL statement for execution.

   233 Note that:

   234 - CSqlStatementImpl can prepare and execute both parametrized SQL statements and SQL statements

   235   without parameters;

   236 - CSqlStatementImpl cannot prepare and execute SQL strings containing more than one SQL statement;

   238 @param aImpl A reference to CSqlStatementImpl pointer which will be set to point to the created instance

   239 @param aDatabase A reference to CSqlDatabaseImpl object.

   240 @param aSqlStmt 8-bit string containing the SQL statement.

   242 @return KErrNoMemory, an out of memory condition has occurred;

   243  	    KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.

   244                       Note that the function may leave with some database specific errors categorised as

   245                       ESqlDbError or other system-wide error codes;

   246         KErrNone      Operation has completed successfully.

   248 @see RSqlStatement

   249 @see RSqlStatement::Prepare()

   250 */

   251 inline TInt CSqlStatementImpl::New(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const TDesC8& aSqlStmt)

   252 	{

   253 	return SqlCreateStatement(aImpl, aDatabase, aSqlStmt);

   254 	}

   256 /**

   257 @return Non-zero if CSqlStatementImpl object points at a valid record, zero otherwise.

   259 @see RSqlStatement::AtRow()

   260 */

   261 inline TBool CSqlStatementImpl::AtRow() const

   262 	{

   263 	return iState == CSqlStatementImpl::EAtRow;

   264 	}

   266 /**

   267 Implements RSqlStatement::ColumnCount().

   269 @see RSqlStatement::ColumnCount().

   271 @return The column count of the statement

   272 */

   273 inline TInt CSqlStatementImpl::ColumnCount() const

   274 	{

   275 	return iColumnCnt;

   276 	}

   278 /**

   279 Gets the index (starting from 0) of the parameter with the given name.

   281 The function does a case insensitive parameter name search.

   283 If the parameter name is ":Prm", then the ":" prefix cannot be omitted when you call ParameterIndex().

   285 This function can be called at any time after the SQL statement has been prepared.

   287 @param aParamName Parameter name

   289 @return the parameter index value, if successful - this is a non-negative integer value;

   290         KErrNotFound, if no such parameter can be found.

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

   293 @see RSqlStatement::ParamIndex()

   294 */

   295 inline TInt CSqlStatementImpl::ParamIndex(const TDesC& aParamName)

   296 	{

   297 	return Name2Index(aParamName, iParamNameBuf, iParamCnt, ESqlSrvStmtParamNames, iParamNameBufPresent);

   298 	}

   300 /**

   301 Gets the index (starting from 0) of the column with the given name.

   303 The function does a case insensitive column name search.

   305 This function can be called at any time after the SQL statement has been prepared.

   307 @param aColumnName Column name

   309 @return the column index value, if successful - this is a non-negative integer value;

   310         KErrNotFound, if no such parameter can be found.

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

   313 @see RSqlStatement::ColumnIndex()

   314 */

   315 inline TInt CSqlStatementImpl::ColumnIndex(const TDesC& aColumnName)

   316 	{

   317 	return Name2Index(aColumnName, iColumnNameBuf, iColumnCnt, ESqlSrvStmtColumnNames, iColumnNameBufPresent);

   318 	}

   320 /**

   321 Gives an access to the content of the requested column as a stream of bytes or characters.

   323 The method creates a read-only MStreamBuf derived object which allows the column with aColumnIndex index

   324 to be accessed as a stream of bytes (if the column is a binary column) or characters

   325 (if the column is a text column) and returns it to the caller.

   327 The caller is responsible for the destroying of the read-only MStreamBuf derived object.

   329 ColumnSourceL() can be used only after successful Next() call (Next() returned KSqlAtRow),

   330 otherwise the method issues panic 11.

   332 @param aColumnIndex Column index (starting from 0)

   333 @return A pointer to the created read-only memory MStreamBuf derived object.

   335 @leave KErrNoMemory, an out of memory condition has occurred;

   337 @panic SqlDb  5 Column index out of bounds.

   338 @panic SqlDb  7 In _DEBUG mode. aColumnIndex index does not refer to a text or binary column.

   339 @panic SqlDb 11 Statement object not positioned at row.

   341 @see RSqlColumnReadStream

   342 */

   343 inline MStreamBuf* CSqlStatementImpl::ColumnSourceL(TInt aColumnIndex)

   344 	{

   345 	__ASSERT_ALWAYS((TUint)aColumnIndex < (TUint)iColumnCnt, __SQLPANIC(ESqlPanicBadColumnIndex));

   346 	__ASSERT_ALWAYS(iState == CSqlStatementImpl::EAtRow, __SQLPANIC(ESqlPanicInvalidRow));

   347 	iColumnValBufIt.MoveTo(aColumnIndex);

   348 	return iColumnValBufIt.IsPresent() ? iColumnValBufIt.StreamL() : iSqlStmtSession.ColumnSourceL(aColumnIndex);

   349 	}

   351 /**

   352 Gives an access to the content of the requested parameter as a stream of bytes or characters.

   354 The method creates an IPC object with buffering capabilities, allowing to stream out the data of the

   355 parameter with aParameterIndex index and returns this MStreamBuf derived object to the caller.

   357 The caller is responsible for the destroying of the MStreamBuf derived object.

   359 @param aFunction Requested operation

   360 @param aParamIndex Parameter index (starting from 0)

   362 @return A pointer to the created MStreamBuf derived object.

   364 @leave KErrNoMemory, an out of memory condition has occurred;

   366 @panic SqlDb 5 Parameter index out of bounds.

   368 @see RSqlParamWriteStream

   369 */

   370 inline MStreamBuf* CSqlStatementImpl::ParamSinkL(TSqlSrvFunction aFunction, TInt aParamIndex)

   371 	{

   372 	__ASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, __SQLPANIC(ESqlPanicBadColumnIndex));

   373 	return iSqlStmtSession.ParamSinkL(aFunction, aParamIndex);

   374 	}

   376 /**

   377 Sets the internal state of CSqlStatementImpl instance to CSqlStatementImpl::EUnknown.

   378 */

   379 inline CSqlStatementImpl::CSqlStatementImpl() :

   380 	iBound(ETrue),

   381 	iState(CSqlStatementImpl::EUnknown)

   382 	{

   383 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--