1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Client/SqlStatementImpl.inl Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,383 @@
1.4 +// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// /////////////////////// RSqlLongColumnColl ////////////////////////////////////////////
1.18 +// Sets the default granularity of the collection.
1.19 +//
1.20 +//
1.21 +
1.22 +inline RSqlLongColumnColl::RSqlLongColumnColl() :
1.23 + iValues(KLongColumnCollGranularity)
1.24 + {
1.25 + }
1.26 +
1.27 +/**
1.28 +Releases the allocated memory.
1.29 +*/
1.30 +inline void RSqlLongColumnColl::Close()
1.31 + {
1.32 + LONGCOL_INVARIANT();
1.33 + Reset();
1.34 + iValues.Close();
1.35 + }
1.36 +
1.37 +/**
1.38 +Destroys all long column values in the collection, without destroying the collection object.
1.39 +*/
1.40 +inline void RSqlLongColumnColl::Reset()
1.41 + {
1.42 + LONGCOL_INVARIANT();
1.43 + for(TInt i=iValues.Count()-1;i>=0;--i)
1.44 + {
1.45 + delete iValues[i].iData;
1.46 + }
1.47 + iValues.Reset();
1.48 + }
1.49 +
1.50 +/**
1.51 +Constructs and returns a TPtrC object to the long column value, identified by aColumnIndex argument.
1.52 +@param aColumnIndex Column index
1.53 +@return A TPtrC object to the long column value
1.54 +@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
1.55 +@panic SqlDb 7 There is no long column value with aColumnIndex index.
1.56 +*/
1.57 +inline TPtrC RSqlLongColumnColl::Text(TInt aColumnIndex) const
1.58 + {
1.59 + __ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.60 + LONGCOL_INVARIANT();
1.61 + TInt rc = FindValue(aColumnIndex);
1.62 + __ASSERT_ALWAYS(rc >= 0, __SQLPANIC(ESqlPanicInternalError));
1.63 + TPtrC8 ptr(iValues[rc].iData->Des());
1.64 + return TPtrC(reinterpret_cast <const TUint16*> (ptr.Ptr()), ptr.Length() / sizeof(TUint16));
1.65 + }
1.66 +
1.67 +/**
1.68 +Constructs and returns a TPtrC8 object to the long column value, identified by aColumnIndex argument.
1.69 +@param aColumnIndex Column index
1.70 +@return A TPtrC8 object to the long column value
1.71 +@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
1.72 +@panic SqlDb 7 There is no long column value with aColumnIndex index.
1.73 +*/
1.74 +inline TPtrC8 RSqlLongColumnColl::Binary(TInt aColumnIndex) const
1.75 + {
1.76 + __ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.77 + LONGCOL_INVARIANT();
1.78 + TInt rc = FindValue(aColumnIndex);
1.79 + __ASSERT_ALWAYS(rc >= 0, __SQLPANIC(ESqlPanicInternalError));
1.80 + return iValues[rc].iData->Des();
1.81 + }
1.82 +
1.83 +/**
1.84 +Returns true if there is a long column value in the collection, which index is aColumnIndex.
1.85 +@param aColumnIndex Column index
1.86 +@return True if there is a long column value in the collection, which index is aColumnIndex.
1.87 +@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
1.88 +*/
1.89 +inline TBool RSqlLongColumnColl::IsPresent(TInt aColumnIndex) const
1.90 + {
1.91 + __ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.92 + LONGCOL_INVARIANT();
1.93 + return FindValue(aColumnIndex) >= 0;
1.94 + }
1.95 +
1.96 +/**
1.97 +The method returns the index in the collection of the long column value, identified by aColumnIndex argument.
1.98 +@param aColumnIndex Column index
1.99 +@return The collection index of the long column value, identified by aColumnIndex,
1.100 + KErrNotFound otherwise.
1.101 +@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative.
1.102 +*/
1.103 +inline TInt RSqlLongColumnColl::FindValue(TInt aColumnIndex) const
1.104 + {
1.105 + __ASSERT_DEBUG(aColumnIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.106 + return iValues.Find(aColumnIndex, &RSqlLongColumnColl::TData::Compare);
1.107 + }
1.108 +
1.109 +/**
1.110 +Initializes the RSqlLongColumnColl::TData instance with the column index, and a pointer to the column data
1.111 +@param aIndex Column index
1.112 +@param aData A HBufC8 pointer to the column data. Cannot be NULL, this is a long column value
1.113 +@panic SqlDb 4 In _DEBUG mode, aColumnIndex value is negative or aData is NULL.
1.114 +*/
1.115 +inline RSqlLongColumnColl::TData::TData(TInt aIndex, HBufC8* aData) :
1.116 + iIndex(aIndex),
1.117 + iData(aData)
1.118 + {
1.119 + __ASSERT_DEBUG(aIndex >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.120 + __ASSERT_DEBUG(aData != NULL, __SQLPANIC(ESqlPanicBadArgument));
1.121 + }
1.122 +
1.123 +/////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.124 +////////////////////////// CSqlStatementImpl ////////////////////////////////////////////
1.125 +/////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.126 +
1.127 +/**
1.128 +Initializes the created CSqlDatabaseImpl object.
1.129 +Works with 8/16-bit SQL statements.
1.130 +
1.131 +@param aDatabase A reference to CSqlDatabaseImpl object.
1.132 +@param aSqlStmt 8/16-bit string containing the SQL statement.
1.133 +
1.134 +@return KErrNoMemory, an out of memory condition has occurred;
1.135 + KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
1.136 + Note that the function may leave with some database specific errors categorised as
1.137 + ESqlDbError or other system-wide error codes;
1.138 + KErrNone Operation has completed successfully.
1.139 +
1.140 +@panic SqlDb 7 In _DEBUG mode, invalid column count.
1.141 +
1.142 +@see CSqlStatementImpl::New()
1.143 +*/
1.144 +template <class DES> TInt CSqlStatementImpl::Construct(CSqlDatabaseImpl& aDatabase, const DES& aSqlStmt)
1.145 + {
1.146 + TInt err = iSqlStmtSession.Prepare(aDatabase.Session(), aSqlStmt, iColumnCnt, iParamCnt);
1.147 + if(err != KErrNone)
1.148 + {
1.149 + return err;
1.150 + }
1.151 + __ASSERT_DEBUG(iColumnCnt >= 0, __SQLPANIC(ESqlPanicInternalError));
1.152 + err = iColumnValueBuf.SetCount(iColumnCnt);
1.153 + if(err != KErrNone)
1.154 + {
1.155 + return err;
1.156 + }
1.157 + iColumnValBufIt.Set(iColumnValueBuf);
1.158 + if(iParamCnt > 0)
1.159 + {
1.160 + err = iParamValueBuf.SetCount(iParamCnt);
1.161 + if(err != KErrNone)
1.162 + {
1.163 + return err;
1.164 + }
1.165 + iParamValBufIt.Set(iParamValueBuf);
1.166 + }
1.167 + return KErrNone;
1.168 + }
1.169 +
1.170 +/**
1.171 +Template function, friend of CSqlStatementImpl, that is used for creation of CSqlStatementImpl objects.
1.172 +
1.173 +@param aImpl A reference to a CSqlStatementImpl pointer. Will be initialized after a successfull CSqlStatementImpl construction.
1.174 +@param aDatabase A reference to a CSqlDatabaseImpl object.
1.175 +@param aSqlStmt The SQL statement: 8-bit or 16-bit.
1.176 +
1.177 +@return KErrNoMemory, an out of memory condition has occurred;
1.178 + KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
1.179 + Note that the function may leave with some database specific errors categorised as
1.180 + ESqlDbError or other system-wide error codes;
1.181 + KErrNone Operation has completed successfully.
1.182 +
1.183 +@internalComponent
1.184 +*/
1.185 +template <class DES> TInt SqlCreateStatement(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const DES& aSqlStmt)
1.186 + {
1.187 + TInt err = KErrNoMemory;
1.188 + aImpl = new CSqlStatementImpl;
1.189 + if(aImpl)
1.190 + {
1.191 + err = aImpl->Construct(aDatabase, aSqlStmt);
1.192 + }
1.193 + if(err != KErrNone)
1.194 + {
1.195 + delete aImpl;
1.196 + aImpl = NULL;
1.197 + }
1.198 + return err;
1.199 + }
1.200 +
1.201 +/**
1.202 +Factory function for creating CSqlStatementImpl objects.
1.203 +Works with 16-bit SQL statements.
1.204 +
1.205 +Creates CSqlStatementImpl instance and prepares the supplied SQL statement for execution.
1.206 +
1.207 +Note that:
1.208 +- CSqlStatementImpl can prepare and execute both parametrized SQL statements and SQL statements
1.209 + without parameters;
1.210 +- CSqlStatementImpl cannot prepare and execute SQL strings containing more than one SQL statement;
1.211 +
1.212 +@param aImpl A reference to CSqlStatementImpl pointer which will be set to point to the created instance
1.213 +@param aDatabase A reference to CSqlDatabaseImpl object.
1.214 +@param aSqlStmt 16-bit string containing the SQL statement.
1.215 +
1.216 +@return KErrNoMemory, an out of memory condition has occurred;
1.217 + KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
1.218 + Note that the function may leave with some database specific errors categorised as
1.219 + ESqlDbError or other system-wide error codes;
1.220 + KErrNone Operation has completed successfully.
1.221 +
1.222 +@see RSqlStatement
1.223 +@see RSqlStatement::Prepare()
1.224 +*/
1.225 +inline TInt CSqlStatementImpl::New(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const TDesC16& aSqlStmt)
1.226 + {
1.227 + return SqlCreateStatement(aImpl, aDatabase, aSqlStmt);
1.228 + }
1.229 +
1.230 +/**
1.231 +Factory function for creating CSqlStatementImpl objects.
1.232 +Works with 8-bit SQL statements.
1.233 +
1.234 +Creates CSqlStatementImpl instance and prepares the supplied SQL statement for execution.
1.235 +
1.236 +Note that:
1.237 +- CSqlStatementImpl can prepare and execute both parametrized SQL statements and SQL statements
1.238 + without parameters;
1.239 +- CSqlStatementImpl cannot prepare and execute SQL strings containing more than one SQL statement;
1.240 +
1.241 +@param aImpl A reference to CSqlStatementImpl pointer which will be set to point to the created instance
1.242 +@param aDatabase A reference to CSqlDatabaseImpl object.
1.243 +@param aSqlStmt 8-bit string containing the SQL statement.
1.244 +
1.245 +@return KErrNoMemory, an out of memory condition has occurred;
1.246 + KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
1.247 + Note that the function may leave with some database specific errors categorised as
1.248 + ESqlDbError or other system-wide error codes;
1.249 + KErrNone Operation has completed successfully.
1.250 +
1.251 +@see RSqlStatement
1.252 +@see RSqlStatement::Prepare()
1.253 +*/
1.254 +inline TInt CSqlStatementImpl::New(CSqlStatementImpl*& aImpl, CSqlDatabaseImpl& aDatabase, const TDesC8& aSqlStmt)
1.255 + {
1.256 + return SqlCreateStatement(aImpl, aDatabase, aSqlStmt);
1.257 + }
1.258 +
1.259 +/**
1.260 +@return Non-zero if CSqlStatementImpl object points at a valid record, zero otherwise.
1.261 +
1.262 +@see RSqlStatement::AtRow()
1.263 +*/
1.264 +inline TBool CSqlStatementImpl::AtRow() const
1.265 + {
1.266 + return iState == CSqlStatementImpl::EAtRow;
1.267 + }
1.268 +
1.269 +/**
1.270 +Implements RSqlStatement::ColumnCount().
1.271 +
1.272 +@see RSqlStatement::ColumnCount().
1.273 +
1.274 +@return The column count of the statement
1.275 +*/
1.276 +inline TInt CSqlStatementImpl::ColumnCount() const
1.277 + {
1.278 + return iColumnCnt;
1.279 + }
1.280 +
1.281 +/**
1.282 +Gets the index (starting from 0) of the parameter with the given name.
1.283 +
1.284 +The function does a case insensitive parameter name search.
1.285 +
1.286 +If the parameter name is ":Prm", then the ":" prefix cannot be omitted when you call ParameterIndex().
1.287 +
1.288 +This function can be called at any time after the SQL statement has been prepared.
1.289 +
1.290 +@param aParamName Parameter name
1.291 +
1.292 +@return the parameter index value, if successful - this is a non-negative integer value;
1.293 + KErrNotFound, if no such parameter can be found.
1.294 + One of the other system-wide error codes may also be returned.
1.295 +
1.296 +@see RSqlStatement::ParamIndex()
1.297 +*/
1.298 +inline TInt CSqlStatementImpl::ParamIndex(const TDesC& aParamName)
1.299 + {
1.300 + return Name2Index(aParamName, iParamNameBuf, iParamCnt, ESqlSrvStmtParamNames, iParamNameBufPresent);
1.301 + }
1.302 +
1.303 +/**
1.304 +Gets the index (starting from 0) of the column with the given name.
1.305 +
1.306 +The function does a case insensitive column name search.
1.307 +
1.308 +This function can be called at any time after the SQL statement has been prepared.
1.309 +
1.310 +@param aColumnName Column name
1.311 +
1.312 +@return the column index value, if successful - this is a non-negative integer value;
1.313 + KErrNotFound, if no such parameter can be found.
1.314 + One of the other system-wide error codes may also be returned.
1.315 +
1.316 +@see RSqlStatement::ColumnIndex()
1.317 +*/
1.318 +inline TInt CSqlStatementImpl::ColumnIndex(const TDesC& aColumnName)
1.319 + {
1.320 + return Name2Index(aColumnName, iColumnNameBuf, iColumnCnt, ESqlSrvStmtColumnNames, iColumnNameBufPresent);
1.321 + }
1.322 +
1.323 +/**
1.324 +Gives an access to the content of the requested column as a stream of bytes or characters.
1.325 +
1.326 +The method creates a read-only MStreamBuf derived object which allows the column with aColumnIndex index
1.327 +to be accessed as a stream of bytes (if the column is a binary column) or characters
1.328 +(if the column is a text column) and returns it to the caller.
1.329 +
1.330 +The caller is responsible for the destroying of the read-only MStreamBuf derived object.
1.331 +
1.332 +ColumnSourceL() can be used only after successful Next() call (Next() returned KSqlAtRow),
1.333 +otherwise the method issues panic 11.
1.334 +
1.335 +@param aColumnIndex Column index (starting from 0)
1.336 +@return A pointer to the created read-only memory MStreamBuf derived object.
1.337 +
1.338 +@leave KErrNoMemory, an out of memory condition has occurred;
1.339 +
1.340 +@panic SqlDb 5 Column index out of bounds.
1.341 +@panic SqlDb 7 In _DEBUG mode. aColumnIndex index does not refer to a text or binary column.
1.342 +@panic SqlDb 11 Statement object not positioned at row.
1.343 +
1.344 +@see RSqlColumnReadStream
1.345 +*/
1.346 +inline MStreamBuf* CSqlStatementImpl::ColumnSourceL(TInt aColumnIndex)
1.347 + {
1.348 + __ASSERT_ALWAYS((TUint)aColumnIndex < (TUint)iColumnCnt, __SQLPANIC(ESqlPanicBadColumnIndex));
1.349 + __ASSERT_ALWAYS(iState == CSqlStatementImpl::EAtRow, __SQLPANIC(ESqlPanicInvalidRow));
1.350 + iColumnValBufIt.MoveTo(aColumnIndex);
1.351 + return iColumnValBufIt.IsPresent() ? iColumnValBufIt.StreamL() : iSqlStmtSession.ColumnSourceL(aColumnIndex);
1.352 + }
1.353 +
1.354 +/**
1.355 +Gives an access to the content of the requested parameter as a stream of bytes or characters.
1.356 +
1.357 +The method creates an IPC object with buffering capabilities, allowing to stream out the data of the
1.358 +parameter with aParameterIndex index and returns this MStreamBuf derived object to the caller.
1.359 +
1.360 +The caller is responsible for the destroying of the MStreamBuf derived object.
1.361 +
1.362 +@param aFunction Requested operation
1.363 +@param aParamIndex Parameter index (starting from 0)
1.364 +
1.365 +@return A pointer to the created MStreamBuf derived object.
1.366 +
1.367 +@leave KErrNoMemory, an out of memory condition has occurred;
1.368 +
1.369 +@panic SqlDb 5 Parameter index out of bounds.
1.370 +
1.371 +@see RSqlParamWriteStream
1.372 +*/
1.373 +inline MStreamBuf* CSqlStatementImpl::ParamSinkL(TSqlSrvFunction aFunction, TInt aParamIndex)
1.374 + {
1.375 + __ASSERT_ALWAYS((TUint)aParamIndex < (TUint)iParamCnt, __SQLPANIC(ESqlPanicBadColumnIndex));
1.376 + return iSqlStmtSession.ParamSinkL(aFunction, aParamIndex);
1.377 + }
1.378 +
1.379 +/**
1.380 +Sets the internal state of CSqlStatementImpl instance to CSqlStatementImpl::EUnknown.
1.381 +*/
1.382 +inline CSqlStatementImpl::CSqlStatementImpl() :
1.383 + iBound(ETrue),
1.384 + iState(CSqlStatementImpl::EUnknown)
1.385 + {
1.386 + }