1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Server/SqlSrvStatement.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,835 @@
1.4 +// Copyright (c) 2005-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 +// NTT DOCOMO, INC - Fix for defect 1915 "SQL server panics when using long column type strings"
1.16 +//
1.17 +// Description:
1.18 +//
1.19 +
1.20 +#include <utf.h> //CnvUtfConverter
1.21 +#include <e32math.h>
1.22 +#include "SqliteSymbian.h" //sqlite3SymbianLastOsError()
1.23 +#include "sqlite3.h"
1.24 +#include "SqlSrvStatement.h"
1.25 +#include "SqlBufIterator.h" //TSqlBufRIterator
1.26 +#include "SqlSrvResourceProfiler.h"
1.27 +#include "OstTraceDefinitions.h"
1.28 +#ifdef OST_TRACE_COMPILER_IN_USE
1.29 +#include "SqlSrvStatementTraces.h"
1.30 +#endif
1.31 +#include "SqlTraceDef.h"
1.32 +
1.33 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.34 +///////////////////////////// local const data ////////////////////////////////////////////
1.35 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.36 +
1.37 +//This is the name prefix which will be given to the nameless parameters.
1.38 +//For example, if the SQL string is:
1.39 +// SELECT * FROM A WHERE ColA1 = ? AND ColA2 = ?
1.40 +//then the names which will be given to the parameters will be:
1.41 +//"?0" and "?1"
1.42 +_LIT(KNamelessParameter, "?");
1.43 +
1.44 +
1.45 +/////////////////////////////////////////////////////////////////////////////////////////////////////////
1.46 +////////////////// HSqlSrvStmtParamBuf //////////////////////////////////
1.47 +/////////////////////////////////////////////////////////////////////////////////////////////////////////
1.48 +
1.49 +/**
1.50 +Destroys the parameter buffer.
1.51 +
1.52 +Virtual method.
1.53 +*/
1.54 +HSqlSrvStmtParamBuf::~HSqlSrvStmtParamBuf()
1.55 + {
1.56 + delete iBuf;
1.57 + }
1.58 +
1.59 +/**
1.60 +Binds the parameter value.
1.61 +The buffer can be synch-ed if:
1.62 + - this is the first synch operation;
1.63 + - the bound statement object is still alive (not finalized);
1.64 + - the current object is alive;
1.65 + - the current object data is retrieved from an IPC stream;
1.66 +
1.67 +If none of the conditions above is true, the synch operation is no-op.
1.68 +
1.69 +Virtual method.
1.70 +*/
1.71 +void HSqlSrvStmtParamBuf::DoSynchL()
1.72 + {
1.73 + TBool dontSynch = iSynchDone || !iAlive || iStatementFinalized || iBufType != HSqlSrvStmtParamBuf::EBufIpcStream;
1.74 + if(dontSynch)
1.75 + {
1.76 + return;
1.77 + }
1.78 + iSynchDone = ETrue;
1.79 + TBufBuf::DoSynchL();
1.80 + iStatement.BindParamBufL(iParamIndex);
1.81 + }
1.82 +
1.83 +/**
1.84 +Destroys the HSqlSrvStmtParamBuf instance.
1.85 +This method is a no-op if the statement is not finalized yet.
1.86 +
1.87 +Virtual method.
1.88 +*/
1.89 +void HSqlSrvStmtParamBuf::DoRelease()
1.90 + {
1.91 + iAlive = EFalse;
1.92 + if(iStatementFinalized)
1.93 + {//The bound statement has been finalized - destroy the current object then.
1.94 + delete this;
1.95 + }
1.96 + }
1.97 +
1.98 +/**
1.99 +This function is called by the bound statement object to notify the current HSqlSrvStmtParamBuf object that the
1.100 +bound statement is about to be finalized. That means, when the "stream close" operation on the client side
1.101 +makes an attempt to synch the HSqlSrvStmtParamBuf object, no attempt should be made to bound the parameter data,
1.102 +because the statement object is gone.
1.103 +After this call the bound statement objects ceases to exist.
1.104 +
1.105 +Actions, performed by this method:
1.106 + - if the buffer type is "simple bind", the buffer will be destroyed. No reason to keep it alive, there is no bound IPC
1.107 + stream object on the client side;
1.108 + - if the buffer type is an IPC stream buffer and the buffer is alive, that means: the bound statement object is about to be
1.109 + finalized, but there is a bound client side IPC stream object that is still alive. In this case the buffer won't be destroyed,
1.110 + but will be "told" that the bound statement is finalized, so when the client side IPC stream is closed, this object will get destroyed;
1.111 + - if the buffer type is an IPC stream buffer and the buffer is "dead", that means there is no bound IPC stream object on the client
1.112 + side and it is safe to destroy the buffer;
1.113 +
1.114 +*/
1.115 +void HSqlSrvStmtParamBuf::NotifyStatementFinalized()
1.116 + {
1.117 + iStatementFinalized = ETrue;
1.118 + if(iBufType == HSqlSrvStmtParamBuf::EBufSimpleBind || !iAlive)
1.119 + {
1.120 + DoRelease();
1.121 + }
1.122 + }
1.123 +
1.124 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.125 +///////////////////////////// CSqlSrvStatement class ////////////////////////////////////////////
1.126 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.127 +
1.128 +/**
1.129 +Creates a new CSqlSrvStatement instance.
1.130 +
1.131 +The created CSqlSrvStatement instance will be placed in the cleanup stack.
1.132 +
1.133 +@param aDbHandle The database handle
1.134 +@param aSqlStmt 16-bit SQL statement, zero-terminated string
1.135 +@param aColumnCount Output parameter. It will be initialized with the column count.
1.136 +@param aParamCount Output parameter. It will be initialized with the parameter count.
1.137 +
1.138 +@return A pointer to the created CSqlSrvStatement instance.
1.139 +
1.140 +@leave KErrNoMemory, an out of memory condition has occurred;
1.141 + KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
1.142 + Note that the function may also leave with some other database specific
1.143 + errors categorised as ESqlDbError.
1.144 +
1.145 +@panic SqlDb 4 In _DEBUG mode if aSqlStmt is not zero-terminated string.
1.146 +*/
1.147 +CSqlSrvStatement* CSqlSrvStatement::NewLC(sqlite3* aDbHandle, const TDesC16& aSqlStmt, TInt& aColumnCount, TInt& aParamCount)
1.148 + {
1.149 + __SQLTRACE_INTERNALSEXPR(TPtrC sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
1.150 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVSTATEMENT_NEWLC_ENTRY, "Entry;0;CSqlSrvStatement::NewLC-16;aDbHandle=0x%X;aSqlStmt=%S", (TUint)aDbHandle, __SQLPRNSTR(sqlprnptr)));
1.151 + __ASSERT_DEBUG(aSqlStmt.Length() > 0 ? (TInt)aSqlStmt[aSqlStmt.Length() - 1] == 0 : ETrue, __SQLPANIC2(ESqlPanicBadArgument));
1.152 +
1.153 + CSqlSrvStatement* self = new (ELeave) CSqlSrvStatement;
1.154 + CleanupStack::PushL(self);
1.155 + self->ConstructL(aDbHandle, aSqlStmt);
1.156 + aColumnCount = self->iColumnCount;
1.157 + aParamCount = self->iParamCount;
1.158 + SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, CSQLSRVSTATEMENT_NEWLC_EXIT, "Exit;0x%X;CSqlSrvStatement::NewLC-16;iStmtHandle=0x%X;aColumnCount=%d;aParamCount=%d", (TUint)self, (TUint)self->iStmtHandle, aColumnCount, aParamCount));
1.159 + return self;
1.160 + }
1.161 +
1.162 +/**
1.163 +Creates a new CSqlSrvStatement instance.
1.164 +
1.165 +The created CSqlSrvStatement instance will be placed in the cleanup stack.
1.166 +
1.167 +@param aDbHandle The database handle
1.168 +@param aSqlStmt 8-bit SQL statement, zero-terminated string
1.169 +@param aColumnCount Output parameter. It will be initialized with the column count.
1.170 +@param aParamCount Output parameter. It will be initialized with the parameter count.
1.171 +
1.172 +@return A pointer to the created CSqlSrvStatement instance.
1.173 +
1.174 +@leave KErrNoMemory, an out of memory condition has occurred;
1.175 + KErrArgument, bad argument, for example - the SQL string contains more than one SQL statements.
1.176 + Note that the function may also leave with some other database specific
1.177 + errors categorised as ESqlDbError.
1.178 +
1.179 +@panic SqlDb 4 In _DEBUG mode if aSqlStmt is not zero-terminated string.
1.180 +*/
1.181 +CSqlSrvStatement* CSqlSrvStatement::NewLC(sqlite3* aDbHandle, const TDesC8& aSqlStmt, TInt& aColumnCount, TInt& aParamCount)
1.182 + {
1.183 + __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
1.184 + __SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
1.185 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVSTATEMENT_NEWLC_ENTRY2, "Entry;0;CSqlSrvStatement::NewLC-8;aDbHandle=0x%X;aSqlStmt=%s", (TUint)aDbHandle, __SQLPRNSTR8(sqlprnptr, des16prnbuf)));
1.186 + __ASSERT_DEBUG(aSqlStmt.Length() > 0 ? (TInt)aSqlStmt[aSqlStmt.Length() - 1] == 0 : ETrue, __SQLPANIC2(ESqlPanicBadArgument));
1.187 +
1.188 + CSqlSrvStatement* self = new (ELeave) CSqlSrvStatement;
1.189 + CleanupStack::PushL(self);
1.190 + self->ConstructL(aDbHandle, aSqlStmt);
1.191 + aColumnCount = self->iColumnCount;
1.192 + aParamCount = self->iParamCount;
1.193 + SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, CSQLSRVSTATEMENT_NEWLC_EXIT2, "Exit;0x%X;CSqlSrvStatement::NewLC-8;iStmtHandle=0x%X;aColumnCount=%d;aParamCount=%d", (TUint)self, (TUint)self->iStmtHandle, aColumnCount, aParamCount));
1.194 + return self;
1.195 + }
1.196 +
1.197 +/**
1.198 +Destroys the allocated by CSqlSrvStatement instance memory and other resources.
1.199 +*/
1.200 +CSqlSrvStatement::~CSqlSrvStatement()
1.201 + {
1.202 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVSTATEMENT_CSQLSRVSTATEMENT2_ENTRY, "Entry;0x%X;CSqlSrvStatement::~CSqlSrvStatement;iStmtHandle=0x%X", (TUint)this, (TUint)iStmtHandle));
1.203 + DestroyParamBufArray();
1.204 + iBufFlat.Close();
1.205 + if(iStmtHandle)
1.206 + {
1.207 +#ifdef SYMBIAN_USE_SQLITE_VERSION_3_6_4
1.208 + __SQLTRACE_INTERNALSEXPR(TInt scanCount = sqlite3_stmt_status(iStmtHandle, SQLITE_STMTSTATUS_FULLSCAN_STEP, ETrue));
1.209 + __SQLTRACE_INTERNALSEXPR(TInt sortCount = sqlite3_stmt_status(iStmtHandle, SQLITE_STMTSTATUS_SORT, ETrue));
1.210 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVSTATEMENT_CSQLSRVSTATEMENT2, "0x%X;CSqlSrvStatement::~CSqlSrvStatement;scan count=%d;sort count=%d", (TUint)this, scanCount, sortCount));
1.211 +#endif
1.212 + (void)sqlite3_finalize(iStmtHandle);
1.213 + }
1.214 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVSTATEMENT_CSQLSRVSTATEMENT2_EXIT, "Exit;0x%X;CSqlSrvStatement::~CSqlSrvStatement", (TUint)this));
1.215 + }
1.216 +
1.217 +/**
1.218 +Sets SQL statement parameter values.
1.219 +
1.220 +Only parameters, whose values are set by the client, will be processed.
1.221 +
1.222 +@param aParamBuf Flat buffer with parameter values.
1.223 +
1.224 +@leave KErrArgument, unknown parameter type;
1.225 + KSqlErrStmtExpired, statement handle expired.
1.226 + Note that the function may also leave with some other database specific
1.227 + errors categorised as ESqlDbError.
1.228 +
1.229 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.230 +*/
1.231 +void CSqlSrvStatement::BindL(const RSqlBufFlat& aParamBuf)
1.232 + {
1.233 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.234 +
1.235 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.236 +
1.237 + TSqlBufRIterator it;
1.238 + it.Set(aParamBuf);
1.239 + TInt prmIdx = 0;
1.240 +
1.241 + TInt err = SQLITE_OK;
1.242 + while(it.Next() && err == SQLITE_OK)
1.243 + {
1.244 + ++prmIdx;//the first SQLITE parameter index is 1
1.245 + if(it.IsPresent())
1.246 + {
1.247 + switch(it.Type())
1.248 + {
1.249 + case ESqlInt:
1.250 + err = sqlite3_bind_int(iStmtHandle, prmIdx, it.Int());
1.251 + break;
1.252 + case ESqlInt64:
1.253 + err = sqlite3_bind_int64(iStmtHandle, prmIdx, it.Int64());
1.254 + break;
1.255 + case ESqlReal:
1.256 + err = sqlite3_bind_double(iStmtHandle, prmIdx, it.Real());
1.257 + break;
1.258 + case ESqlText:
1.259 + //SQLITE_STATIC is used as an argument, because the text data will be kept and can be used by the next bind call
1.260 + {
1.261 + TPtrC text = it.Text();
1.262 + TPtrC8 prmDataCopy(reinterpret_cast <const TUint8*> (text.Ptr()), text.Length() * sizeof(TUint16));
1.263 + prmDataCopy.Set(CopyAndStoreParamL(prmIdx - 1, HSqlSrvStmtParamBuf::EText16, prmDataCopy));
1.264 + err = sqlite3_bind_text16(iStmtHandle, prmIdx, prmDataCopy.Ptr(), prmDataCopy.Length(), SQLITE_STATIC);
1.265 + }
1.266 + break;
1.267 + case ESqlBinary:
1.268 + //SQLITE_STATIC is used as an argument, because the blob data will be kept and can be used by the next bind call
1.269 + {
1.270 + TPtrC8 prmDataCopy = CopyAndStoreParamL(prmIdx - 1, HSqlSrvStmtParamBuf::EBinary, it.Binary());
1.271 + err = sqlite3_bind_blob(iStmtHandle, prmIdx, prmDataCopy.Ptr(), prmDataCopy.Length(), SQLITE_STATIC);
1.272 + }
1.273 + break;
1.274 + case ESqlNull:
1.275 + err = sqlite3_bind_null(iStmtHandle, prmIdx);
1.276 + break;
1.277 + case ESqlZeroBlob:
1.278 + err = sqlite3_bind_zeroblob(iStmtHandle, prmIdx, it.Int());
1.279 + break;
1.280 + default:
1.281 + __SQLLEAVE(KErrArgument);//unknown parameter type
1.282 + break;
1.283 + }
1.284 + }//end of - if(it.IsPresent())
1.285 + }//end of - while(it.Next() && err == SQLITE_OK)
1.286 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.287 + __SQLLEAVE_IF_ERROR(err);
1.288 + }
1.289 +
1.290 +/**
1.291 +Collects column names in a flat buffer and returns a reference to the buffer.
1.292 +
1.293 +@return A const reference to a flat buffer containing the column names.
1.294 +
1.295 +@leave KErrNoMemory, an out of memory condition has occurred.
1.296 +
1.297 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.298 +*/
1.299 +const RSqlBufFlat& CSqlSrvStatement::ColumnNamesL()
1.300 + {
1.301 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.302 + iBufFlatType = static_cast <TSqlBufFlatType> (-1);
1.303 + __SQLLEAVE_IF_ERROR(iBufFlat.SetCount(iColumnCount));
1.304 + TSqlBufWIterator it;
1.305 + it.Set(iBufFlat);
1.306 + TInt colIdx = -1;
1.307 + while(it.Next())
1.308 + {
1.309 + ++colIdx;//the first SQLITE column index is 0
1.310 + const TUint16* name = reinterpret_cast <const TUint16*> (__SQLLEAVE_IF_NULL(const_cast <void*> (sqlite3_column_name16(iStmtHandle, colIdx))));
1.311 + TPtrC ptr(name, User::StringLength(name));
1.312 + __SQLLEAVE_IF_ERROR(it.SetText(ptr));
1.313 + }
1.314 + iBufFlatType = ESqlColumnNamesBuf;
1.315 + SQLPROFILER_REPORT_ALLOC(iBufFlat.MaxSize());
1.316 + return iBufFlat;
1.317 + }
1.318 +
1.319 +/**
1.320 +Collects parameter names in a flat buffer and returns a reference to the buffer.
1.321 +
1.322 +@return A const reference to a flat buffer containing the parameter names.
1.323 +
1.324 +@leave KErrNoMemory, an out of memory condition has occurred.
1.325 +
1.326 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.327 +*/
1.328 +const RSqlBufFlat& CSqlSrvStatement::ParamNamesL()
1.329 + {
1.330 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.331 + iBufFlatType = static_cast <TSqlBufFlatType> (-1);
1.332 + __SQLLEAVE_IF_ERROR(iBufFlat.SetCount(iParamCount));
1.333 + TSqlBufWIterator it;
1.334 + it.Set(iBufFlat);
1.335 + TInt prmIdx = 0;
1.336 + while(it.Next())
1.337 + {
1.338 + ++prmIdx;//the first SQLITE parameter index is 1
1.339 + const TUint8* name8 = reinterpret_cast <const TUint8*> (sqlite3_bind_parameter_name(iStmtHandle, prmIdx));
1.340 + if(name8)
1.341 + {
1.342 + HBufC* name = CnvUtfConverter::ConvertToUnicodeFromUtf8L(TPtrC8(name8, User::StringLength(name8)));
1.343 + TInt err = it.SetText(name->Des());
1.344 + delete name;
1.345 + __SQLLEAVE_IF_ERROR(err);
1.346 + }
1.347 + else //nameless parameter case
1.348 + {
1.349 + //The parameter name in this case will be formatted as "?<num>", where <num> is the parameter index.
1.350 + TBuf<5> prmName;
1.351 + prmName.Append(KNamelessParameter);
1.352 + prmName.AppendNum((TInt64)(prmIdx - 1));
1.353 + __SQLLEAVE_IF_ERROR(it.SetText(prmName));
1.354 + }
1.355 + }
1.356 + iBufFlatType = ESqlParamNamesBuf;
1.357 + SQLPROFILER_REPORT_ALLOC(iBufFlat.MaxSize());
1.358 + return iBufFlat;
1.359 + }
1.360 +
1.361 +/**
1.362 +Collects the column values in a flat buffer and returns a reference to the buffer.
1.363 +
1.364 +@leave KErrNoMemory, an out of memory condition has occurred.
1.365 +
1.366 +@return A const reference to a flat buffer containing the column values.
1.367 +
1.368 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object
1.369 +*/
1.370 +const RSqlBufFlat& CSqlSrvStatement::ColumnValuesL()
1.371 + {
1.372 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.373 +
1.374 + iBufFlatType = static_cast <TSqlBufFlatType> (-1);
1.375 + iBufFlat.SetCount(iColumnCount);
1.376 + TSqlBufWIterator it;
1.377 + it.Set(iBufFlat);
1.378 + TInt colIdx = -1;
1.379 +
1.380 + while(it.Next())
1.381 + {
1.382 + ++colIdx;//the first SQLITE column index is 0
1.383 + TInt colType = sqlite3_column_type(iStmtHandle, colIdx);
1.384 + switch(colType)
1.385 + {
1.386 + case SQLITE_INTEGER:
1.387 + {
1.388 + TInt64 val = sqlite3_column_int64(iStmtHandle, colIdx);
1.389 + __SQLLEAVE_IF_ERROR(val == TInt64(TInt32(val)) ? it.SetInt(static_cast <TInt> (val)) : it.SetInt64(val));
1.390 + }
1.391 + break;
1.392 + case SQLITE_FLOAT:
1.393 + __SQLLEAVE_IF_ERROR(it.SetReal(sqlite3_column_double(iStmtHandle, colIdx)));
1.394 + break;
1.395 + case SQLITE_TEXT:
1.396 + {
1.397 + TInt charLength = (TUint)sqlite3_column_bytes16(iStmtHandle, colIdx) / sizeof(TUint16);
1.398 + //"charLength == 0" - this might be an indication of an "out of memory" problem, if the column text is in UTF8 format.
1.399 + //(sqlite3_column_bytes16() may allocate memory for UTF8->UTF16 conversion)
1.400 + if(charLength == 0 && sqlite3_errcode(sqlite3_db_handle(iStmtHandle)) == SQLITE_NOMEM)
1.401 + {
1.402 + __SQLLEAVE(KErrNoMemory);
1.403 + }
1.404 + if(charLength >= KSqlMaxDesLen)
1.405 + {
1.406 + it.SetAsNotPresent(ESqlText, charLength);
1.407 + }
1.408 + else
1.409 + {//sqlite3_column_bytes16() already allocated the needed memory if a UTF8->UTF16 conversion
1.410 + //had to be performed. The sqlite3_column_text16() on the next line is guaranteed to succeed.
1.411 + const TUint16* text = reinterpret_cast <const TUint16*> (sqlite3_column_text16(iStmtHandle, colIdx));
1.412 + __ASSERT_DEBUG(text != NULL, __SQLPANIC(ESqlPanicInternalError));
1.413 + __SQLLEAVE_IF_ERROR(it.SetText(TPtrC16(text, charLength)));
1.414 + }
1.415 + }
1.416 + break;
1.417 + case SQLITE_BLOB:
1.418 + {
1.419 + TInt byteLength = sqlite3_column_bytes(iStmtHandle, colIdx);
1.420 + if(byteLength >= KSqlMaxDesLen)
1.421 + {
1.422 + it.SetAsNotPresent(ESqlBinary, byteLength);
1.423 + }
1.424 + else
1.425 + {
1.426 + __SQLLEAVE_IF_ERROR(it.SetBinary(TPtrC8(reinterpret_cast <const TUint8*> (sqlite3_column_blob(iStmtHandle, colIdx)), byteLength)));
1.427 + }
1.428 + }
1.429 + break;
1.430 + case SQLITE_NULL:
1.431 + it.SetNull();
1.432 + break;
1.433 + default:
1.434 + __ASSERT_DEBUG(EFalse, __SQLPANIC(ESqlPanicInternalError));
1.435 + break;
1.436 + }//end of switch(...)
1.437 + }//end of - while(it.Next())
1.438 + iBufFlatType = ESqlColumnValuesBuf;
1.439 + SQLPROFILER_REPORT_ALLOC(iBufFlat.MaxSize());
1.440 + return iBufFlat;
1.441 + }
1.442 +
1.443 +/**
1.444 +This method sets aColumnSource parameter to point to the column data.
1.445 +
1.446 +@param aColumnIndex Column Index, zero based.
1.447 +@param aColumnSource Output parameter. It is set to point to the column data.
1.448 +
1.449 +@return KErrNone, the operation completed successfully;
1.450 + KErrArgument, the refered by aColumnIndex index column is not a binary or text column.
1.451 +
1.452 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.453 +*/
1.454 +TInt CSqlSrvStatement::ColumnSource(TInt aColumnIndex, TPtrC8& aColumnSource) const
1.455 + {
1.456 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.457 + TInt colType = sqlite3_column_type(iStmtHandle, aColumnIndex);
1.458 + if(colType == SQLITE_TEXT)
1.459 + {//Since the first called function after the Next() operation is always CSqlSrvStatement::ColumnValuesL(), then
1.460 + //sqlite3_column_bytes16() (called from ColumnValuesL()) already allocated the needed memory if a UTF8->UTF16
1.461 + //conversion had to be performed. The sqlite3_column_text16() on the next line is guaranteed to succeed.
1.462 + const void* text = sqlite3_column_text16(iStmtHandle, aColumnIndex);
1.463 + __ASSERT_DEBUG(text != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.464 + TInt length = sqlite3_column_bytes16(iStmtHandle, aColumnIndex);
1.465 + aColumnSource.Set(reinterpret_cast <const TUint8*> (text), length);
1.466 + }
1.467 + else if(colType == SQLITE_BLOB)
1.468 + {
1.469 + const void* data = sqlite3_column_blob(iStmtHandle, aColumnIndex);
1.470 + TInt length = sqlite3_column_bytes(iStmtHandle, aColumnIndex);
1.471 + aColumnSource.Set(reinterpret_cast <const TUint8*> (data), length);
1.472 + }
1.473 + else
1.474 + {
1.475 + return KErrArgument;
1.476 + }
1.477 + return KErrNone;
1.478 + }
1.479 +
1.480 +/**
1.481 +Retrieves from the SQLITE library columns and parameters count.
1.482 +
1.483 +@panic SqlDb 4 In _DEBUG mode. aDbHandle is NULL.
1.484 +*/
1.485 +void CSqlSrvStatement::DoCommonConstructL()
1.486 + {
1.487 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.488 + iColumnCount = sqlite3_column_count(iStmtHandle);
1.489 + iParamCount = sqlite3_bind_parameter_count(iStmtHandle);
1.490 + __SQLLEAVE_IF_ERROR(iBufFlat.SetCount(Max(iColumnCount, iParamCount)));
1.491 + }
1.492 +
1.493 +/**
1.494 +Destroys the parameter buffer array (used for text or binary parameters).
1.495 +Before the array destruction, each array member is notified that the statement is about to be finalized.
1.496 +*/
1.497 +void CSqlSrvStatement::DestroyParamBufArray()
1.498 + {
1.499 + TInt idx = iParamBufArray.Count();
1.500 + while(--idx >= 0)
1.501 + {
1.502 + if(iParamBufArray[idx])
1.503 + {
1.504 + iParamBufArray[idx]->NotifyStatementFinalized();
1.505 + }
1.506 + }
1.507 + iParamBufArray.Close();
1.508 + }
1.509 +
1.510 +/**
1.511 +Binds a streamed text or binary parameter value.
1.512 +
1.513 +@param aParamIndex The text/binary parameter index
1.514 +
1.515 +@leave KErrNoMemory, an out of memory condition has occurred;
1.516 + KSqlErrStmtExpired, statement handle has expired.
1.517 + Note that the function may also leave with some other database specific
1.518 + errors categorised as ESqlDbError.
1.519 +
1.520 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.521 +@panic SqlDb 4 In _DEBUG mode. No parameter buffer has been created yet for this parameter.
1.522 +@panic SqlDb 4 In _DEBUG mode. Parameter index out of bounds.
1.523 +*/
1.524 +void CSqlSrvStatement::BindParamBufL(TInt aParamIndex)
1.525 + {
1.526 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.527 + __ASSERT_DEBUG(aParamIndex >= 0 && aParamIndex < sqlite3_bind_parameter_count(iStmtHandle), __SQLPANIC(ESqlPanicBadArgument));
1.528 + __ASSERT_DEBUG(aParamIndex < iParamBufArray.Count(), __SQLPANIC(ESqlPanicBadArgument));
1.529 + __ASSERT_DEBUG(iParamBufArray[aParamIndex] != NULL, __SQLPANIC(ESqlPanicBadArgument));
1.530 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.531 + //Bind the parameter value.
1.532 + //SQLITE_STATIC is used as an argument, because the text/blob data will be kept and can be used by the next bind call
1.533 + HSqlSrvStmtParamBuf& paramBuf = *iParamBufArray[aParamIndex];
1.534 + const TPtrC8 paramData(paramBuf.Data());
1.535 + SQLPROFILER_REPORT_ALLOC(paramData.Length());
1.536 + TInt err = KErrNone;
1.537 + ++aParamIndex;//SQLite uses positive parameter indexes, the SQL server - parameter indexes begin from 0
1.538 + switch(paramBuf.DataType())
1.539 + {
1.540 + case HSqlSrvStmtParamBuf::EText16:
1.541 + //sqlite3_bind_text16() expects 4-th argument to be the bytes count, not the characters count.
1.542 + err = sqlite3_bind_text16(iStmtHandle, aParamIndex, paramData.Ptr(), paramData.Length(), SQLITE_STATIC);
1.543 + break;
1.544 + case HSqlSrvStmtParamBuf::EBinary:
1.545 + default:
1.546 + err = sqlite3_bind_blob(iStmtHandle, aParamIndex, paramData.Ptr(), paramData.Length(), SQLITE_STATIC);
1.547 + break;
1.548 + }
1.549 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.550 + __SQLLEAVE_IF_ERROR(err);
1.551 + }
1.552 +
1.553 +/**
1.554 +@return Represents the content of the column identified by aColIdx as integer value.
1.555 + If the current column type does not refer to an integer, then
1.556 + the function will do a data conversion as described in the table which can be found
1.557 + in SqlDb.h file.
1.558 +@see RSqlStatement
1.559 +
1.560 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.561 +@panic SqlDb 4 In _DEBUG mode. Invalid aColIdx value.
1.562 +*/
1.563 +TInt CSqlSrvStatement::ColumnInt(TInt aColIdx) const
1.564 + {
1.565 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.566 + __ASSERT_DEBUG((TUint)aColIdx < iColumnCount, __SQLPANIC(ESqlPanicBadArgument));
1.567 + TInt colType = sqlite3_column_type(iStmtHandle, aColIdx);
1.568 + switch(colType)
1.569 + {
1.570 + case SQLITE_FLOAT:
1.571 + {
1.572 + TReal roundVal;
1.573 + TInt err = Math::Round(roundVal, sqlite3_column_double(iStmtHandle, aColIdx), 0);
1.574 + if(err != KErrNone)
1.575 + {
1.576 + return KMinTInt;
1.577 + }
1.578 + TRealX val(roundVal);
1.579 + return static_cast <TInt> (val);
1.580 + }
1.581 + case SQLITE_NULL:
1.582 + case SQLITE_TEXT:
1.583 + case SQLITE_BLOB:
1.584 + return 0;
1.585 + default: //int, int64
1.586 + {
1.587 + TInt64 val = sqlite3_column_int64(iStmtHandle, aColIdx);
1.588 + return val == (TInt)val ? (TInt)val : (val < KMinTInt ? KMinTInt : KMaxTInt);
1.589 + }
1.590 + }
1.591 + }
1.592 +
1.593 +/**
1.594 +@return Represents the content of the column identified by aColIdx as 64-bit integer value.
1.595 + If the current column type does not refer to a 64-bit integer, then
1.596 + the function will do a data conversion as described in the table which can be found
1.597 + in SqlDb.h file.
1.598 +@see RSqlStatement
1.599 +
1.600 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.601 +@panic SqlDb 4 In _DEBUG mode. Invalid aColIdx value.
1.602 +*/
1.603 +TInt64 CSqlSrvStatement::ColumnInt64(TInt aColIdx) const
1.604 + {
1.605 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.606 + __ASSERT_DEBUG((TUint)aColIdx < iColumnCount, __SQLPANIC(ESqlPanicBadArgument));
1.607 + TInt colType = sqlite3_column_type(iStmtHandle, aColIdx);
1.608 + switch(colType)
1.609 + {
1.610 + case SQLITE_FLOAT:
1.611 + {
1.612 + TReal roundVal;
1.613 + TInt err = Math::Round(roundVal, sqlite3_column_double(iStmtHandle, aColIdx), 0);
1.614 + if(err != KErrNone)
1.615 + {
1.616 + return KMinTInt64;
1.617 + }
1.618 + TRealX val(roundVal);
1.619 + return static_cast <TInt64> (val);
1.620 + }
1.621 + case SQLITE_NULL:
1.622 + case SQLITE_TEXT:
1.623 + case SQLITE_BLOB:
1.624 + return 0;
1.625 + default: //int, int64
1.626 + return sqlite3_column_int64(iStmtHandle, aColIdx);
1.627 + }
1.628 + }
1.629 +
1.630 +/**
1.631 +@return Represents the content of the column identified by aColIdx as real value.
1.632 + If the current column type does not refer to a real, then
1.633 + the function will do a data conversion as described in the table which can be found
1.634 + in SqlDb.h file.
1.635 +@see RSqlStatement
1.636 +
1.637 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.638 +@panic SqlDb 4 In _DEBUG mode. Invalid aColIdx value.
1.639 +*/
1.640 +TReal CSqlSrvStatement::ColumnReal(TInt aColIdx) const
1.641 + {
1.642 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.643 + __ASSERT_DEBUG((TUint)aColIdx < iColumnCount, __SQLPANIC(ESqlPanicBadArgument));
1.644 + TInt colType = sqlite3_column_type(iStmtHandle, aColIdx);
1.645 + switch(colType)
1.646 + {
1.647 + case SQLITE_INTEGER:
1.648 + {
1.649 + TRealX val(sqlite3_column_int64(iStmtHandle, aColIdx));
1.650 + return static_cast <TReal> (val);
1.651 + }
1.652 + case SQLITE_NULL:
1.653 + case SQLITE_TEXT:
1.654 + case SQLITE_BLOB:
1.655 + return 0.0;
1.656 + default:
1.657 + return sqlite3_column_double(iStmtHandle, aColIdx);
1.658 + }
1.659 + }
1.660 +
1.661 +/**
1.662 +Represents the content of the column identified by aColIdx as text (16 bit) descriptor.
1.663 +If the current column type does not refer to a text block of data, then
1.664 +the function will do a data conversion as described in the table which can be found
1.665 +in SqlDb.h file.
1.666 +
1.667 +@see RSqlStatement
1.668 +
1.669 +@leave KErrNoMemory, an out of memory condition has occurred.
1.670 +
1.671 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.672 +@panic SqlDb 4 In _DEBUG mode. Invalid aColIdx value.
1.673 +*/
1.674 +TPtrC CSqlSrvStatement::ColumnTextL(TInt aColIdx) const
1.675 + {
1.676 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.677 + __ASSERT_DEBUG((TUint)aColIdx < iColumnCount, __SQLPANIC(ESqlPanicBadArgument));
1.678 + TPtrC res;
1.679 + TInt colType = sqlite3_column_type(iStmtHandle, aColIdx);
1.680 + if(colType == SQLITE_TEXT)
1.681 + {
1.682 + TInt charLength = (TUint)sqlite3_column_bytes16(iStmtHandle, aColIdx) / sizeof(TUint16);
1.683 + //"charLength == 0" - this might be an indication of an "out of memory" problem, if the column text is in UTF8 format.
1.684 + //(sqlite3_column_bytes16() may allocate memory for UTF8->UTF16 conversion)
1.685 + if(charLength == 0 && sqlite3_errcode(sqlite3_db_handle(iStmtHandle)) == SQLITE_NOMEM)
1.686 + {
1.687 + __SQLLEAVE(KErrNoMemory);
1.688 + }
1.689 + //sqlite3_column_bytes16() already allocated the needed memory if a UTF8->UTF16 conversion
1.690 + //had to be performed. The sqlite3_column_text16() on the next line is guaranteed to succeed.
1.691 + const TUint16* text = reinterpret_cast <const TUint16*> (sqlite3_column_text16(iStmtHandle, aColIdx));
1.692 + __ASSERT_DEBUG(text != NULL, __SQLPANIC(ESqlPanicInternalError));
1.693 + res.Set(text, charLength);
1.694 + }
1.695 + return res;
1.696 + }
1.697 +
1.698 +/**
1.699 +Represents the content of the column identified by aColIdx as binary (8 bit) descriptor.
1.700 +If the current column type does not refer to a binary block of data, then
1.701 +the function will do a data conversion as described in the table which can be found
1.702 +in SqlDb.h file.
1.703 +
1.704 +@see RSqlStatement
1.705 +
1.706 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.707 +@panic SqlDb 4 In _DEBUG mode. Invalid aColIdx value.
1.708 +*/
1.709 +TPtrC8 CSqlSrvStatement::ColumnBinary(TInt aColIdx) const
1.710 + {
1.711 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.712 + __ASSERT_DEBUG((TUint)aColIdx < iColumnCount, __SQLPANIC(ESqlPanicBadArgument));
1.713 + TPtrC8 res;
1.714 + TInt colType = sqlite3_column_type(iStmtHandle, aColIdx);
1.715 + if(colType == SQLITE_BLOB)
1.716 + {
1.717 + TInt byteLength = sqlite3_column_bytes(iStmtHandle, aColIdx);
1.718 + res.Set(reinterpret_cast <const TUint8*> (sqlite3_column_blob(iStmtHandle, aColIdx)), byteLength);
1.719 + }
1.720 + return res;
1.721 + }
1.722 +
1.723 +/**
1.724 +Retrieves the declared column types using the SQLITE library storing in a
1.725 +flat buffer and returns a reference to the buffer.
1.726 +
1.727 +@return A const reference to a flat buffer containing the declared column type names.
1.728 +
1.729 +@leave KErrNoMemory, an out of memory condition has occurred;
1.730 +
1.731 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.732 +*/
1.733 +const RSqlBufFlat& CSqlSrvStatement::GetDeclColumnTypesL()
1.734 + {
1.735 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.736 + iBufFlatType = static_cast <TSqlBufFlatType> (-1);
1.737 + __SQLLEAVE_IF_ERROR(iBufFlat.SetCount(iColumnCount));
1.738 + TSqlBufWIterator it;
1.739 + it.Set(iBufFlat);
1.740 + TInt colIdx = -1;
1.741 + while(it.Next())
1.742 + {
1.743 + ++colIdx;//the first SQLITE column index is 0
1.744 + const TUint16* declTypeTxt = reinterpret_cast <const TUint16*> (sqlite3_column_decltype16(iStmtHandle, colIdx));
1.745 + TPtrC ptr(KNullDesC);
1.746 + if(declTypeTxt)
1.747 + {
1.748 + ptr.Set(declTypeTxt, User::StringLength(declTypeTxt));
1.749 + }
1.750 + else
1.751 + {
1.752 + //If sqlite3_column_decltype16() returns NULL but sqlite3_column_decltype() doesn't, then it is an "out of memory" condition
1.753 + if(sqlite3_column_decltype(iStmtHandle, colIdx))
1.754 + {
1.755 + __SQLLEAVE(KErrNoMemory);
1.756 + }
1.757 + }
1.758 + __SQLLEAVE_IF_ERROR(it.SetText(ptr));
1.759 + }
1.760 + iBufFlatType = ESqlDeclColumnTypesBuf;
1.761 + return iBufFlat;
1.762 + }
1.763 +
1.764 +
1.765 +/**
1.766 +Creates a new HSqlSrvStmtParamBuf object for the parameter with index "aParamIndex" or
1.767 +reuses the existing one.
1.768 +
1.769 +@param aParamIndex Parameter index, zero based.
1.770 +@param aDataType Parameter value type - binary, text8 or text16.
1.771 +@param aIsStreamBuf True if the param data will be retrieved from an IPC stream
1.772 +
1.773 +@return A pointer to the created HSqlSrvStmtParamBuf instance.
1.774 +
1.775 +@leave KErrNoMemory, an out of memory condition has occurred;
1.776 +*/
1.777 +HSqlSrvStmtParamBuf* CSqlSrvStatement::GetParamBufL(TInt aParamIndex, HSqlSrvStmtParamBuf::TDataType aDataType,
1.778 + HSqlSrvStmtParamBuf::TBufType aBufType)
1.779 + {
1.780 + __ASSERT_DEBUG(aParamIndex >= 0 && aParamIndex < sqlite3_bind_parameter_count(iStmtHandle), __SQLPANIC(ESqlPanicBadArgument));
1.781 + ExtendParamBufArrayL(aParamIndex);
1.782 + HSqlSrvStmtParamBuf*& paramBuf = iParamBufArray[aParamIndex];
1.783 + if(paramBuf)
1.784 + {//Reset and reuse the existing buffer
1.785 + __ASSERT_DEBUG(paramBuf->ParamIndex() == aParamIndex, __SQLPANIC(ESqlPanicInternalError));
1.786 + paramBuf->Reset(aDataType, aBufType);
1.787 + }
1.788 + else
1.789 + {
1.790 + paramBuf = HSqlSrvStmtParamBuf::NewL(*this, aParamIndex, aDataType, aBufType);
1.791 + }
1.792 + return paramBuf;
1.793 + }
1.794 +
1.795 +/**
1.796 +This function will extend the iParamBufArray array (filling the new array items with NULL), if it is needed -
1.797 +to ensure that there is enough place in the buffer for the parameter identified by aParamIndex.
1.798 +
1.799 +@param aParamIndex The parameter index
1.800 +
1.801 +@leave KErrNoMemory, an out of memory condition has occurred;
1.802 +
1.803 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.804 +@panic SqlDb 4 In _DEBUG mode. Parameter index out of bounds.
1.805 +*/
1.806 +void CSqlSrvStatement::ExtendParamBufArrayL(TInt aParamIndex)
1.807 + {
1.808 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.809 + __ASSERT_DEBUG(aParamIndex >= 0 && aParamIndex < sqlite3_bind_parameter_count(iStmtHandle), __SQLPANIC(ESqlPanicBadArgument));
1.810 + TInt ext = aParamIndex - iParamBufArray.Count() + 1;
1.811 + while(ext-- > 0)
1.812 + {
1.813 + __SQLLEAVE_IF_ERROR(iParamBufArray.Append(NULL));
1.814 + }
1.815 + }
1.816 +
1.817 +/**
1.818 +This function will create a copy of the aParamValue and store it in the iParamBufArray array for later use.
1.819 +The reason: once bound, the parameter value can be used multiple times by the SQLite if it is not set explicitly again.
1.820 +
1.821 +@param aParamIndex The parameter index
1.822 +@param aDataType Parameter value type - binary, text8 or text16.
1.823 +@param aParamValue The parameter value
1.824 +
1.825 +@return 8-bit descriptor to the stored parameter value
1.826 +
1.827 +@leave KErrNoMemory, an out of memory condition has occurred;
1.828 +
1.829 +@panic SqlDb 2 In _DEBUG mode. Invalid (not created) CSqlSrvStatement object.
1.830 +@panic SqlDb 4 In _DEBUG mode. Parameter index out of bounds.
1.831 +*/
1.832 +TPtrC8 CSqlSrvStatement::CopyAndStoreParamL(TInt aParamIndex, HSqlSrvStmtParamBuf::TDataType aDataType, const TDesC8& aParamValue)
1.833 + {
1.834 + __ASSERT_DEBUG(iStmtHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.835 + __ASSERT_DEBUG(aParamIndex >= 0 && aParamIndex < sqlite3_bind_parameter_count(iStmtHandle), __SQLPANIC(ESqlPanicBadArgument));
1.836 + HSqlSrvStmtParamBuf* paramBuf = GetParamBufL(aParamIndex, aDataType, HSqlSrvStmtParamBuf::EBufSimpleBind);
1.837 + return paramBuf->SetDataL(aParamValue);
1.838 + }