1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Server/SqlSrvStatementUtil.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,926 @@
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 +//
1.18 +
1.19 +#include <e32debug.h>
1.20 +#include <hal.h>
1.21 +#include <sqldb.h>
1.22 +#include "sqlite3.h"
1.23 +#include "SqlSrvStatementUtil.h"
1.24 +#include "SqlAssert.h"
1.25 +#include "SqlSrvUtil.h"
1.26 +#include "SqlUtil.h"
1.27 +#include "SqliteSymbian.h" //sqlite3SymbianLastOsError()
1.28 +#include "OstTraceDefinitions.h"
1.29 +#include "SqlSrvResourceProfiler.h"
1.30 +#ifdef OST_TRACE_COMPILER_IN_USE
1.31 +#include "SqlSrvStatementUtilTraces.h"
1.32 +#endif
1.33 +#include "SqlTraceDef.h"
1.34 +
1.35 +//The database names in all statements are quoted to avoid the "sql injection" threat.
1.36 +_LIT8(KPageCountPragma, "PRAGMA \"%S\".page_count\x0");
1.37 +_LIT8(KPageSizePragma, "PRAGMA \"%S\".page_size\x0");
1.38 +_LIT8(KCacheSizePragma, "PRAGMA \"%S\".cache_size\x0");
1.39 +_LIT8(KEncodingPragma, "PRAGMA \"%S\".encoding\x0");
1.40 +_LIT8(KFreePageCountPragma, "PRAGMA \"%S\".freelist_count\x0");
1.41 +_LIT8(KVacuumModePragma, "PRAGMA \"%S\".auto_vacuum\x0");
1.42 +_LIT8(KIncrementalVacuumPragma, "PRAGMA \"%S\".incremental_vacuum(%d)\x0");
1.43 +
1.44 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.45 +
1.46 +//Calls sqlite3_open16() to create or open database file with aFileNameZ.
1.47 +//aFileNameZ is UTF16 encoded, zero-terminated.
1.48 +//The function returns system-wide errors or database specific errors.
1.49 +//The function may panic with code 7 in _DEBUG mode - internal error: the created database handle is NULL.
1.50 +TInt CreateDbHandle16(const TDesC& aFileNameZ, sqlite3*& aDbHandle)
1.51 + {
1.52 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.53 + TInt err = sqlite3_open16(aFileNameZ.Ptr(), &aDbHandle);
1.54 + __ASSERT_DEBUG(err == SQLITE_OK ? aDbHandle != NULL : ETrue, __SQLPANIC2(ESqlPanicInternalError));
1.55 + if(err == SQLITE_OK)
1.56 + {
1.57 + (void)sqlite3_extended_result_codes(aDbHandle, 0);
1.58 + }
1.59 + //Get the return error code now, because the next "if" may destroy it.
1.60 + TInt rc = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.61 + if(err != SQLITE_OK)
1.62 + {//Yes, it is possible error code != SQLITE_OK and aDbHandle != NULL.
1.63 + CloseDbHandle(aDbHandle);
1.64 + aDbHandle = NULL;
1.65 + }
1.66 + return rc;
1.67 + }
1.68 +
1.69 +//Calls sqlite3_open() to create or open database file with aFileNameZ.
1.70 +//aFileNameZ is UTF8 encoded, zero-terminated.
1.71 +//The function returns system-wide errors or database specific errors.
1.72 +//The function may panic with code 7 in _DEBUG mode - internal error: the created database handle is NULL.
1.73 +TInt CreateDbHandle8(const TDesC8& aFileNameZ, sqlite3*& aDbHandle)
1.74 + {
1.75 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.76 + TInt err = sqlite3_open((const char *) aFileNameZ.Ptr(), &aDbHandle);
1.77 + __ASSERT_DEBUG(err == SQLITE_OK ? aDbHandle != NULL : ETrue, __SQLPANIC2(ESqlPanicInternalError));
1.78 + if(err == SQLITE_OK)
1.79 + {
1.80 + (void)sqlite3_extended_result_codes(aDbHandle, 0);
1.81 + }
1.82 + //Get the return error code now, because the next "if" may destroy it.
1.83 + TInt rc = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.84 + if(err != SQLITE_OK)
1.85 + {//Yes, it is possible error code != SQLITE_OK and aDbHandle != NULL.
1.86 + CloseDbHandle(aDbHandle);
1.87 + aDbHandle = NULL;
1.88 + }
1.89 + return rc;
1.90 + }
1.91 +
1.92 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.93 +///// 16-bit and 8-bit SQL statements execution upon completion ////
1.94 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.95 +
1.96 +//16-bit SQL statement execution.
1.97 +//
1.98 +//aSql - zero-terminated string
1.99 +//
1.100 +//Prepares the supplied as an argument (aSql) 16-bit SQL statement and executes it.
1.101 +//If aSql argument contains more than one SQL statements, separated with ';', then
1.102 +//the function panics in _DEBUG mode (panic code 7).
1.103 +//
1.104 +//The function panics in debug mode (panic code 2) if aDbHandle is NULL.
1.105 +//
1.106 +//If the function completes successfully, it returns SQLITE_ROW or SQLITE_DONE.
1.107 +//If the function fails then it returns one of the SQLITE error codes.
1.108 +static TInt DoSingleStmtExec16(sqlite3 *aDbHandle, const TDesC16& aSql)
1.109 + {
1.110 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
1.111 + __ASSERT_DEBUG(aSql.Length() > 0 ? (TInt)aSql[aSql.Length() - 1] == 0 : ETrue, __SQLPANIC2(ESqlPanicBadArgument));
1.112 + sqlite3_stmt* stmtHandle = NULL;
1.113 + const void* stmtTail = NULL;
1.114 + //sqlite3_prepare16_v2() expects parameter #3 to be one of the following:
1.115 + // - byte length of the sql statement (parameter #2), excluding terminating zero;
1.116 + // - negative value - the sql statement (parameter #2) is zero-terminated;
1.117 + TInt err = sqlite3_prepare16_v2(aDbHandle, aSql.Ptr(), aSql.Length() * sizeof(TUint16) - sizeof(TUint16), &stmtHandle, &stmtTail);
1.118 + __ASSERT_DEBUG(err == SQLITE_OK ? !stmtTail || User::StringLength((const TUint16*)stmtTail) == 0 : !stmtHandle, __SQLPANIC2(ESqlPanicInternalError));
1.119 + if(stmtHandle) //stmtHandle can be NULL for statements like this: ";".
1.120 + {
1.121 + if(err == SQLITE_OK)
1.122 + {
1.123 + while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)
1.124 + {
1.125 + }
1.126 + if(err == SQLITE_ERROR) //It may be "out of memory" problem
1.127 + {
1.128 + err = sqlite3_reset(stmtHandle);
1.129 + __ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
1.130 + }
1.131 + }
1.132 + (void)sqlite3_finalize(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
1.133 + }
1.134 + return err;
1.135 + }
1.136 +
1.137 +/**
1.138 +This function searches aString argument for ';' occurences.
1.139 +Every time when it finds a ';' character, the function places a zero character right after the ';' and
1.140 +tests the just created, zero-terminated substring if it is a comlpete SQL statement.
1.141 +
1.142 +If it is a SQL statement, the function replaces the found ';' character with zero and returns the just created
1.143 +zero-terminated substring.Also the function modifies aString argument to point right after the found
1.144 +SQL string. If it is not SQL statement, the function will continue the searching.
1.145 +
1.146 +If there is no ';' inside aString argument, the function returns the same string as a return result and
1.147 +modifies aString argument - sets it to TPtr(NULL, 0, 0).
1.148 +
1.149 +The function expects aString argument to be zero-terminated.
1.150 +
1.151 +@internalComponent
1.152 +*/
1.153 +TPtrC GetFirstSqlStmt(TPtr& aString)
1.154 + {
1.155 + const TChar KDelimitier(';');
1.156 + TPtr originalStr(aString);
1.157 + TPtr str(const_cast <TUint16*> (aString.Ptr()), aString.Length(), aString.Length());
1.158 + TInt afterDelimitierPos = 0;
1.159 + TInt pos;
1.160 + while((pos = str.Locate(KDelimitier) + 1) > 0 && pos < str.Length())
1.161 + {
1.162 + //There is a possibility that the string, which terminates with the found ';' character, is a SQL statement.
1.163 + //Zero terminate the string placing a zero right after the ';' character and test it using sqlite3_complete16().
1.164 + //If it is not a SQL string, restore the original character and continue searching.
1.165 + afterDelimitierPos += pos;
1.166 + TChar ch = aString[afterDelimitierPos];
1.167 + aString[afterDelimitierPos] = 0;
1.168 + TInt res = sqlite3_complete16(aString.Ptr());
1.169 + aString[afterDelimitierPos] = ch;
1.170 + if(res)
1.171 + {
1.172 + str.Set(const_cast <TUint16*> (aString.Ptr()), afterDelimitierPos, afterDelimitierPos);
1.173 + //Replace the found ';' character with 0.
1.174 + str[afterDelimitierPos - 1] = 0;
1.175 + aString.Set(const_cast <TUint16*> (aString.Ptr()) + afterDelimitierPos, aString.Length() - afterDelimitierPos, aString.Length() - afterDelimitierPos);
1.176 + return str;
1.177 + }
1.178 + str.Set(const_cast <TUint16*> (str.Ptr()) + pos, str.Length() - pos, str.Length() - pos);
1.179 + }
1.180 + //aString argument does not contain valid SQL statement or there is no ';' character inside aString.
1.181 + //Set aString to TPtr(NULL, 0, 0) and return the original string.
1.182 + aString.Set(NULL, 0, 0);
1.183 + str.Set(originalStr);
1.184 + return str;
1.185 + }
1.186 +
1.187 +/**
1.188 +Executes one or more 16-bit SQL statements. SQL statements of any kind can be executed, but the
1.189 +method won't return any record(s) if the SQL statement type is "SELECT".
1.190 +If the SQL statement(s) contains one or more parameters, the method will execute it giving the parameters
1.191 +default NULL values.
1.192 +
1.193 +@param aDbHandle Database handle. Not NULL.
1.194 +@param aSqlStmt String containing one or more 16-bit SQL statements, separated with ';'. Zero-terminated string.
1.195 + Note: The ExecL() call can modify the content of aSqlStmt argument.
1.196 +
1.197 +@return KErrNone, Operation completed successfully;
1.198 + KErrNoMemory, Out of memory;
1.199 + KSqlErrGeneral, Syntax error. A text message describing the problem can be obtained calling
1.200 + RSqlDatabase::LastErrorMessage();
1.201 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.202 +
1.203 +@panic SqlDb 4 In _DEBUG mode if aSqlStmt is not zero-terminated string
1.204 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.205 +
1.206 +@internalComponent
1.207 +*/
1.208 +TInt DbExecStmt16(sqlite3* aDbHandle, TDes16& aSqlStmt)
1.209 + {
1.210 + __SQLTRACE_INTERNALSEXPR(TPtrC sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
1.211 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT16_ENTRY, "Entry;0x%X;DbExecStmt16;sql=%S", (TUint)aDbHandle, __SQLPRNSTR(sqlprnptr)));
1.212 +
1.213 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.214 + __ASSERT_DEBUG(aSqlStmt.Length() > 0 ? (TInt)aSqlStmt[aSqlStmt.Length() - 1] == 0: ETrue, __SQLPANIC2(ESqlPanicBadArgument));
1.215 +
1.216 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.217 +
1.218 + TInt err = SQLITE_DONE;
1.219 + //Execute SQL statement(s)
1.220 + //16-bit SQL string - no sqlite3_exec16() function, so the execution is made with
1.221 + //sqlite3_prepare16_v2() and sqlite3_step() functions.
1.222 + TPtr16 sql(const_cast <TUint16*> (aSqlStmt.Ptr()), aSqlStmt.Length(), aSqlStmt.Length());
1.223 + TPtrC firstSqlStmt(KNullDesC);
1.224 + while(err == SQLITE_DONE && sql.Length() > 1) //"> 1" because it is a zero terminated string
1.225 + {
1.226 + firstSqlStmt.Set(GetFirstSqlStmt(sql));
1.227 + SQLPROFILER_SQL16_PRINT((TUint)aDbHandle, firstSqlStmt.Left(firstSqlStmt.Length() - 1), EFalse);
1.228 + err = ::DoSingleStmtExec16(aDbHandle, firstSqlStmt);
1.229 + }
1.230 +
1.231 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.232 + if(err == KSqlAtEnd)
1.233 + {
1.234 + err = KErrNone;
1.235 + }
1.236 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT16_EXIT, "Exit;0x%X;DbExecStmt16;err=%d", (TUint)aDbHandle, err));
1.237 + return err;
1.238 + }
1.239 +
1.240 +/**
1.241 +Executes one or more 8-bit SQL statements. SQL statements of any kind can be executed, but the
1.242 +method won't return any record(s) if the SQL statement type is "SELECT".
1.243 +If the SQL statement(s) contains one or more parameters, the method will execute it giving the parameters
1.244 +default NULL values.
1.245 +
1.246 +@param aDbHandle Database handle. Not NULL.
1.247 +@param aSqlStmt String containing one or more 8-bit SQL statements, separated with ';'. Zero-terminated string.
1.248 +
1.249 +@return KErrNone, Operation completed successfully;
1.250 + KErrNoMemory, Out of memory;
1.251 + KSqlErrGeneral, Syntax error. A text message describing the problem can be obtained calling
1.252 + RSqlDatabase::LastErrorMessage();
1.253 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.254 +
1.255 +@panic SqlDb 4 In _DEBUG mode if aSqlStmt is not zero-terminated string
1.256 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.257 +
1.258 +@internalComponent
1.259 +*/
1.260 +TInt DbExecStmt8(sqlite3* aDbHandle, const TDesC8& aSqlStmt)
1.261 + {
1.262 + __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
1.263 + __SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
1.264 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT8_ENTRY, "Entry;0x%X;DbExecStmt8;sql=%s", (TUint)aDbHandle, __SQLPRNSTR8(sqlprnptr, des16prnbuf)));
1.265 +
1.266 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.267 + __ASSERT_DEBUG(aSqlStmt.Length() > 0 ? (TInt)aSqlStmt[aSqlStmt.Length() - 1] == 0: ETrue, __SQLPANIC2(ESqlPanicBadArgument));
1.268 +
1.269 + SQLPROFILER_SQL8_PRINT((TUint)aDbHandle, aSqlStmt.Left(aSqlStmt.Length() - 1), EFalse);
1.270 +
1.271 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.272 +
1.273 + TInt err = sqlite3_exec(aDbHandle, reinterpret_cast <const char*> (aSqlStmt.Ptr()), NULL, NULL, NULL);
1.274 +
1.275 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.276 + __ASSERT_DEBUG(err != KSqlAtEnd, __SQLPANIC2(ESqlPanicInternalError));
1.277 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT8_EXIT, "Exit;0x%X;DbExecStmt8;err=%d", (TUint)aDbHandle, err));
1.278 + return err;
1.279 + }
1.280 +
1.281 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.282 +///// 16-bit and 8-bit SQL statement preparation /////
1.283 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.284 +
1.285 +//Prepares 16-bit SQL statement, returning in aStmtHandle the statement handle and
1.286 +//setting aHasTail to true, if aStmt contains more than one sql statements.
1.287 +//aStmt - zero-terminated string.
1.288 +//Returns one of SQLITE error codes.
1.289 +static TInt DoPrepareStmt16(sqlite3* aDbHandle, const TDesC& aStmt, sqlite3_stmt** aStmtHandle, TBool& aHasTail)
1.290 + {
1.291 + const void* stmtTail = NULL;
1.292 + //sqlite3_prepare16_v2() expects parameter #3 to be one of the following:
1.293 + // - byte length of the sql statement (parameter #2), excluding terminating zero;
1.294 + // - negative value - the sql statement (parameter #2) is zero-terminated;
1.295 + TInt err = sqlite3_prepare16_v2(aDbHandle, aStmt.Ptr(), aStmt.Length() * sizeof(TUint16) - sizeof(TUint16), aStmtHandle, &stmtTail);
1.296 + aHasTail = stmtTail && static_cast <const TUint16*> (stmtTail)[0] != 0;
1.297 + __ASSERT_DEBUG(err != SQLITE_OK ? !(*aStmtHandle) : ETrue, __SQLPANIC2(ESqlPanicInternalError));
1.298 + //(*aStmtHandle) is NULL for ";" statements, when err == SQLITE_OK. Since the server should not panic
1.299 + //that situation is handled later (not inside the assert above)
1.300 + return err;
1.301 + }
1.302 +
1.303 +//Prepares 8-bit SQL statement, returning in aStmtHandle the statement handle and
1.304 +//setting aHasTail to true, if aStmt contains more than one sql statements.
1.305 +//aStmt - zero-terminated string.
1.306 +//Returns one of SQLITE error codes.
1.307 +static TInt DoPrepareStmt8(sqlite3* aDbHandle, const TUint8* aStmt, sqlite3_stmt** aStmtHandle, TBool& aHasTail)
1.308 + {
1.309 + const char* stmtTail = NULL;
1.310 + //sqlite3_prepare_v2() expects parameter #3 to be one of the following:
1.311 + // - byte length of the sql statement (parameter #2), excluding terminating zero;
1.312 + // - negative value - the sql statement (parameter #2) is zero-terminated;
1.313 + TInt err = sqlite3_prepare_v2(aDbHandle, reinterpret_cast <const char*> (aStmt), -1, aStmtHandle, &stmtTail);
1.314 + aHasTail = stmtTail && stmtTail[0] != 0;
1.315 + __ASSERT_DEBUG(err != SQLITE_OK ? !(*aStmtHandle) : ETrue, __SQLPANIC2(ESqlPanicInternalError));
1.316 + //(*aStmtHandle) is NULL for ";" statements, when err == SQLITE_OK. Since the server should not panic
1.317 + //that situation is handled later (not inside the assert above)
1.318 + return err;
1.319 + }
1.320 +
1.321 +//This function accepts as arguments the SQLITE error code,
1.322 +//"aHasTail" boolean flag set to true if the SQL string contains more than one SQL statement
1.323 +//and the statement handle.
1.324 +//
1.325 +//It checks the arguments and returns an error if:
1.326 +// - aSqliteError != SQLITE_OK;
1.327 +// - aHasTail is true (possibly more than one SQL statement, separated with ";");
1.328 +// - aStmtHandle is NULL;
1.329 +//
1.330 +static TInt ProcessPrepareError(TInt aSqliteError, TBool aHasTail, sqlite3_stmt*& aStmtHandle)
1.331 + {
1.332 + if(aSqliteError != SQLITE_OK)
1.333 + {
1.334 + return ::Sql2OsErrCode(aSqliteError, sqlite3SymbianLastOsError());
1.335 + }
1.336 + else if(aHasTail || !aStmtHandle)
1.337 + {//Case 1:
1.338 + // More than one SQL statement or the SQL string is "" or ";;;" or "; ;; ;".
1.339 + // Report it as an error, because there is no statement handle.
1.340 + //Case 2:
1.341 + // Non-null aHasTail. In this case the SQL string contains more than one SQL statement.
1.342 + // The statement handle is not null. The statement has to be finialized before reporting the error.
1.343 + (void)FinalizeStmtHandle(aStmtHandle);
1.344 + aStmtHandle = NULL;
1.345 + return KErrArgument;
1.346 + }
1.347 + return KErrNone;
1.348 + }
1.349 +
1.350 +//This function accepts as arguments the SQLITE error code,
1.351 +//"aHasTail" boolean flag set to true if the SQL string contains more than one SQL statement
1.352 +//and the statement handle.
1.353 +//
1.354 +//It checks the arguments and leaves if:
1.355 +// - aSqliteError != SQLITE_OK;
1.356 +// - aHasTail is true (possibly more than one SQL statement, separated with ";");
1.357 +// - aStmtHandle is NULL;
1.358 +//
1.359 +static void LeaveIfPrepareErrorL(TInt aSqliteError, TBool aHasTail, sqlite3_stmt* aStmtHandle)
1.360 + {
1.361 + __SQLLEAVE_IF_ERROR2(ProcessPrepareError(aSqliteError, aHasTail, aStmtHandle));
1.362 + }
1.363 +
1.364 +/**
1.365 +Prepares 16-bit aSqlStmt SQL statement.
1.366 +
1.367 +@param aSqlStmt - zero-terminated string.
1.368 +
1.369 +@leave KErrNoMemory, if there is no memory;
1.370 + KErrArgument, if the SQL string contains more than one SQL statements;
1.371 + One of the error codes in [KSqlErrGeneral..KSqlErrNotDb] range.
1.372 +
1.373 +@return The prepared SQL statement handle.
1.374 +
1.375 +@internalComponent
1.376 +*/
1.377 +sqlite3_stmt* StmtPrepare16L(sqlite3* aDbHandle, const TDesC16& aSqlStmt)
1.378 + {
1.379 + __SQLTRACE_INTERNALSEXPR(TPtrC sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
1.380 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE16L_ENTRY, "Entry;0x%X;StmtPrepare16L;sql=%S", (TUint)aDbHandle, __SQLPRNSTR(sqlprnptr)));
1.381 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.382 + TBool hasTail = EFalse;
1.383 + sqlite3_stmt* stmtHandle = NULL;
1.384 + TInt err = DoPrepareStmt16(aDbHandle, aSqlStmt, &stmtHandle, hasTail);
1.385 + LeaveIfPrepareErrorL(err, hasTail, stmtHandle);
1.386 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE16L_EXIT, "Exit;0x%X;StmtPrepare16L;stmtHandle=0x%X", (TUint)aDbHandle, (TUint)stmtHandle));
1.387 + return stmtHandle;
1.388 + }
1.389 +
1.390 +/**
1.391 +Prepares 8-bit aSqlStmt SQL statement.
1.392 +
1.393 +@param aSqlStmt - zero-terminated string.
1.394 +
1.395 +@leave KErrNoMemory, if there is no memory;
1.396 + KErrArgument, if the SQL string contains more than one SQL statements;
1.397 + One of the error codes in [KSqlErrGeneral..KSqlErrNotDb] range.
1.398 +
1.399 +@return The prepared SQL statement handle.
1.400 +
1.401 +@internalComponent
1.402 +*/
1.403 +TInt StmtPrepare8(sqlite3* aDbHandle, const TDesC8& aSqlStmt, sqlite3_stmt*& aStmtHandle)
1.404 + {
1.405 + __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
1.406 + __SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
1.407 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE8_ENTRY, "Entry;0x%X;StmtPrepare8;sql=%s", (TUint)aDbHandle, __SQLPRNSTR8(sqlprnptr, des16prnbuf)));
1.408 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.409 + TBool hasTail = EFalse;
1.410 + TInt err = DoPrepareStmt8(aDbHandle, aSqlStmt.Ptr(), &aStmtHandle, hasTail);
1.411 + err = ProcessPrepareError(err, hasTail, aStmtHandle);
1.412 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, STMTPREPARE8_EXIT, "Exit;0x%X;StmtPrepare8;aStmtHandle=0x%X;err=%d", (TUint)aDbHandle, (TUint)aStmtHandle, err));
1.413 + return err;
1.414 + }
1.415 +
1.416 +/**
1.417 +Prepares 8-bit aSqlStmt SQL statement.
1.418 +
1.419 +@param aSqlStmt - zero-terminated string.
1.420 +
1.421 +@leave KErrNoMemory, if there is no memory;
1.422 + KErrArgument, if the SQL string contains more than one SQL statements;
1.423 + One of the error codes in [KSqlErrGeneral..KSqlErrNotDb] range.
1.424 +
1.425 +@return The prepared SQL statement handle.
1.426 +
1.427 +@internalComponent
1.428 +*/
1.429 +sqlite3_stmt* StmtPrepare8L(sqlite3* aDbHandle, const TDesC8& aSqlStmt)
1.430 + {
1.431 + __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
1.432 + __SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
1.433 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE8L_ENTRY, "Entry;0x%X;StmtPrepare8L;sql=%s", (TUint)aDbHandle, __SQLPRNSTR8(sqlprnptr, des16prnbuf)));
1.434 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.435 + TBool hasTail = EFalse;
1.436 + sqlite3_stmt* stmtHandle = NULL;
1.437 + TInt err = DoPrepareStmt8(aDbHandle, aSqlStmt.Ptr(), &stmtHandle, hasTail);
1.438 + LeaveIfPrepareErrorL(err, hasTail, stmtHandle);
1.439 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE8L_EXIT, "Exit;0x%X;StmtPrepare8L;stmtHandle=0x%X", (TUint)aDbHandle, (TUint)stmtHandle));
1.440 + return stmtHandle;
1.441 + }
1.442 +
1.443 +/**
1.444 +Executes upon completion the prepared SQL statement.
1.445 +
1.446 +@param aStmtHandle Prepared statement handle
1.447 +
1.448 +@return KSqlErrStmtExpired, Statement expired (if new functions or collating sequences are
1.449 + registered or if an authorizer function is added or changed);
1.450 + KErrNoMemory, Out of memory. The statement will be reset;
1.451 + KErrNone, The reset operation completed successfully.
1.452 +
1.453 +@panic SqlDb 2 In _DEBUG mode. Invalid (NULL) statement handle.
1.454 +@panic SqlDb 7 In _DEBUG mode. SQLITE internal error. (SQLITE_ERROR, followed by a sqlite3_reset(), which returns SQLITE_OK)
1.455 +
1.456 +@internalComponent
1.457 +*/
1.458 +TInt StmtExec(sqlite3_stmt* aStmtHandle)
1.459 + {
1.460 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTEXEC_ENTRY, "Entry;0x%X;StmtExec;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
1.461 + __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
1.462 +
1.463 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.464 +
1.465 + TInt err;
1.466 + while((err = sqlite3_step(aStmtHandle)) == SQLITE_ROW)
1.467 + {
1.468 + }
1.469 +
1.470 + if(err == SQLITE_ERROR) //It may be "out of memory" problem
1.471 + {
1.472 + err = sqlite3_reset(aStmtHandle);
1.473 + __ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
1.474 + }
1.475 +
1.476 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.477 + if(err == KSqlAtEnd)
1.478 + {
1.479 + err = KErrNone;
1.480 + }
1.481 +
1.482 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, STMTEXEC_EXIT, "Exit;0x%X;StmtExec;aStmtHandle=0x%X;err=%d", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle, err));
1.483 + return err;
1.484 + }
1.485 +
1.486 +/**
1.487 +Executes the SQL statement moving it to the next row if available.
1.488 +
1.489 +@return KSqlErrStmtExpired Statement expired (if new functions or collating sequences are
1.490 + registered or if an authorizer function is added or changed)
1.491 +@return KSqlAtRow, The next record data is ready for processing by the caller;
1.492 + KSqlAtEnd, No more record data;
1.493 + KSqlErrBusy, Database file is locked;
1.494 + KSqlErrGeneral, Run-time error. Next() should not be called anymore;
1.495 + KSqlErrMisuse, Next() called after KSqlAtEnd or KSqlErrGeneral returned by the previous Next() call;
1.496 + KErrNoMemory, Out of memory. The statement will be reset.
1.497 +
1.498 +@panic SqlDb 2 In _DEBUG mode. Invalid (NULL) statement handle.
1.499 +@panic SqlDb 7 In _DEBUG mode. SQLITE internal error. (SQLITE_ERROR, followed by a sqlite3_reset(), which returns SQLITE_OK)
1.500 +
1.501 +@internalComponent
1.502 +*/
1.503 +TInt StmtNext(sqlite3_stmt* aStmtHandle)
1.504 + {
1.505 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTNEXT_ENTRY, "Entry;0x%X;StmtNext;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
1.506 + __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
1.507 +
1.508 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.509 +
1.510 + TInt err = sqlite3_step(aStmtHandle);
1.511 + if(err == SQLITE_ERROR) //It may be "out of memory" problem
1.512 + {
1.513 + err = sqlite3_reset(aStmtHandle);
1.514 + __ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
1.515 + }
1.516 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.517 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, STMTNEXT_EXIT, "Exit;0x%X;StmtNext;aStmtHandle=0x%X;err=%d", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle, err));
1.518 + return err;
1.519 + }
1.520 +
1.521 +/**
1.522 +Resets the prepared SQL statement to its initial state and makes it ready to be executed again.
1.523 +Any SQL statement parameters that had values bound to them, retain their values.
1.524 +
1.525 +@return KSqlErrStmtExpired, Statement expired (if new functions or collating sequences are
1.526 + registered or if an authorizer function is added or changed);
1.527 + KErrNone, The reset operation completed successfully.
1.528 +
1.529 +@panic SqlDb 2 In _DEBUG mode. Invalid (NULL) statement handle.
1.530 +
1.531 +@internalComponent
1.532 +*/
1.533 +TInt StmtReset(sqlite3_stmt* aStmtHandle)
1.534 + {
1.535 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTRESET_ENTRY, "Entry;0x%X;StmtReset;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
1.536 + __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
1.537 +
1.538 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.539 +
1.540 + TInt err = sqlite3_reset(aStmtHandle);
1.541 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.542 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, STMTRESET_EXIT, "Exit;0x%X;StmtReset;aStmtHandle=0x%X;err=%d", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle, err));
1.543 + return err;
1.544 + }
1.545 +
1.546 +/**
1.547 +Prepares and executes PRAGMA statement and moves the statement cursor on the first row.
1.548 +
1.549 +@param aDbHandle Database handle
1.550 +@param aDbName Attached database name or KNullDesC for the main database
1.551 +@param aPragmaSql Pragma sql statement
1.552 +@param aStmtHandle An output parameter where the statement handle will be stored
1.553 +
1.554 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.555 +@panic SqlDb 4 In _DEBUG mode if aPragmaSql length is 0 or if the statement is not zero-terminated
1.556 +
1.557 +@return KErrNone, Operation completed successfully;
1.558 + KErrNoMemory, Out of memory;
1.559 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.560 +
1.561 +@internalComponent
1.562 +*/
1.563 +static TInt PreRetrievePragmaValue(sqlite3* aDbHandle, const TDesC& aDbName, const TDesC8& aPragmaSql, sqlite3_stmt*& aStmtHandle)
1.564 + {
1.565 + __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aPragmaSql.Left(aPragmaSql.Length() - 1)));
1.566 + __SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
1.567 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, PRERETRIEVEPRAGMAVALUE_ENTRY, "Entry;0x%X;PreRetrievePragmaValue;aDbName=%S;aPragmaSql=%s", (TUint)aDbHandle, __SQLPRNSTR(aDbName), __SQLPRNSTR8(sqlprnptr, des16prnbuf)));
1.568 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.569 + __ASSERT_DEBUG(aPragmaSql.Length() > 0, __SQLPANIC2(ESqlPanicBadArgument));
1.570 + __ASSERT_DEBUG(aPragmaSql[aPragmaSql.Length() - 1] == 0, __SQLPANIC2(ESqlPanicBadArgument));
1.571 + TBuf8<KMaxFileName> dbName;
1.572 + if(!UTF16ToUTF8(aDbName, dbName))
1.573 + {
1.574 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, PRERETRIEVEPRAGMAVALUE_EXIT1, "Exit;0x%X;PreRetrievePragmaValue;err=KErrGeneral", (TUint)aDbHandle));
1.575 + return KErrGeneral;
1.576 + }
1.577 + TBuf8<KMaxFileName + 64> sql;//64 characters is enough for the longest PRAGMA statement
1.578 + if(dbName == KNullDesC8)
1.579 + {
1.580 + sql.Format(aPragmaSql, &KMainDb8);
1.581 + }
1.582 + else
1.583 + {
1.584 + sql.Format(aPragmaSql, &dbName);
1.585 + }
1.586 + aStmtHandle = NULL;
1.587 + TInt err = ::StmtPrepare8(aDbHandle, sql, aStmtHandle);
1.588 + if(err == KErrNone)
1.589 + {
1.590 + __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
1.591 + err = ::StmtNext(aStmtHandle);
1.592 + }
1.593 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, PRERETRIEVEPRAGMAVALUE_EXIT2, "Exit;0x%X;PreRetrievePragmaValue;aStmtHandle=0x%X;err=%d", (TUint)aDbHandle, (TUint)aStmtHandle, err));
1.594 + return err;
1.595 + }
1.596 +
1.597 +/**
1.598 +Prepares and executes PRAGMA statement and retrieves the value of column 0 (the pragma value).
1.599 +
1.600 +@param aDbHandle Database handle
1.601 +@param aDbName Attached database name or KNullDesC for the main database
1.602 +@param aPragmaSql Pragma sql statement
1.603 +@param aPragmaValue An output parameter where the pragma value will be stored
1.604 +
1.605 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.606 +@panic SqlDb 4 In _DEBUG mode if aPragmaSql length is 0 or if the statement is not zero-terminated
1.607 +
1.608 +@return KErrNone, Operation completed successfully;
1.609 + KErrNoMemory, Out of memory;
1.610 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.611 +
1.612 +@internalComponent
1.613 +*/
1.614 +static TInt RetrievePragmaValue(sqlite3* aDbHandle, const TDesC& aDbName, const TDesC8& aPragmaSql, TInt& aPragmaValue)
1.615 + {
1.616 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.617 + __ASSERT_DEBUG(aPragmaSql.Length() > 0, __SQLPANIC2(ESqlPanicBadArgument));
1.618 + __ASSERT_DEBUG(aPragmaSql[aPragmaSql.Length() - 1] == 0, __SQLPANIC2(ESqlPanicBadArgument));
1.619 + sqlite3_stmt* stmtHandle = NULL;
1.620 + TInt err = PreRetrievePragmaValue(aDbHandle, aDbName, aPragmaSql, stmtHandle);
1.621 + if(err == KSqlAtRow)
1.622 + {
1.623 + aPragmaValue = sqlite3_column_int(stmtHandle, 0);
1.624 + err = aPragmaValue >= 0 ? KErrNone : KErrCorrupt;
1.625 + }
1.626 + (void)FinalizeStmtHandle(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
1.627 + return err;
1.628 + }
1.629 +
1.630 +/**
1.631 +Prepares and executes PRAGMA statement and retrieves the value of column 0 (the pragma value) as text.
1.632 +
1.633 +@param aDbHandle Database handle
1.634 +@param aDbName Attached database name or KNullDesC for the main database
1.635 +@param aPragmaSql Pragma sql statement
1.636 +@param aPragmaValue An output parameter where the pragma value will be stored (as text)
1.637 +
1.638 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.639 +@panic SqlDb 4 In _DEBUG mode if aPragmaSql length is 0 or if the statement is not zero-terminated
1.640 +
1.641 +@return KErrNone, Operation completed successfully;
1.642 + KErrNoMemory, Out of memory;
1.643 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.644 +
1.645 +@internalComponent
1.646 +*/
1.647 +static TInt RetrievePragmaValue(sqlite3* aDbHandle, const TDesC& aDbName, const TDesC8& aPragmaSql, TDes8& aPragmaValue)
1.648 + {
1.649 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.650 + __ASSERT_DEBUG(aPragmaSql.Length() > 0, __SQLPANIC2(ESqlPanicBadArgument));
1.651 + __ASSERT_DEBUG(aPragmaSql[aPragmaSql.Length() - 1] == 0, __SQLPANIC2(ESqlPanicBadArgument));
1.652 + sqlite3_stmt* stmtHandle = NULL;
1.653 + TInt err = PreRetrievePragmaValue(aDbHandle, aDbName, aPragmaSql, stmtHandle);
1.654 + if(err == KSqlAtRow)
1.655 + {
1.656 + TPtrC8 ptr(sqlite3_column_text(stmtHandle, 0));
1.657 + aPragmaValue.Copy(ptr);
1.658 + err = KErrNone;
1.659 + }
1.660 + (void)FinalizeStmtHandle(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
1.661 + return err;
1.662 + }
1.663 +
1.664 +/**
1.665 +Retrieves the database pages count.
1.666 +
1.667 +@param aDbHandle Database handle
1.668 +@param aDbName Attached database name or KNullDesC for the main database
1.669 +@param aPageCount An output parameter where the database pages count will be stored
1.670 +
1.671 +@return KErrNone, Operation completed successfully;
1.672 + KErrNoMemory, Out of memory;
1.673 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.674 +
1.675 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.676 +
1.677 +@internalComponent
1.678 +*/
1.679 +TInt DbPageCount(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aPageCount)
1.680 + {
1.681 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.682 + return RetrievePragmaValue(aDbHandle, aDbName, KPageCountPragma, aPageCount);
1.683 + }
1.684 +
1.685 +/**
1.686 +Retrieves the database page size.
1.687 +
1.688 +@param aDbHandle Database handle
1.689 +@param aDbName Attached database name or KNullDesC for the main database
1.690 +@param aPageSize An output parameter where the page size will be stored
1.691 +
1.692 +@return KErrNone, Operation completed successfully;
1.693 + KErrNoMemory, Out of memory;
1.694 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.695 +
1.696 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.697 +
1.698 +@internalComponent
1.699 +*/
1.700 +TInt DbPageSize(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aPageSize)
1.701 + {
1.702 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.703 + return RetrievePragmaValue(aDbHandle, aDbName, KPageSizePragma, aPageSize);
1.704 + }
1.705 +
1.706 +/**
1.707 +Retrieves the database cache size in pages.
1.708 +
1.709 +@param aDbHandle Database handle
1.710 +@param aDbName Attached database name or KNullDesC for the main database
1.711 +@param aCacheSize An output parameter where the cache size will be stored
1.712 +
1.713 +@return KErrNone, Operation completed successfully;
1.714 + KErrNoMemory, Out of memory;
1.715 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.716 +
1.717 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.718 +
1.719 +@internalComponent
1.720 +*/
1.721 +TInt DbCacheSize(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aCacheSize)
1.722 + {
1.723 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.724 + return RetrievePragmaValue(aDbHandle, aDbName, KCacheSizePragma, aCacheSize);
1.725 + }
1.726 +
1.727 +/**
1.728 +Retrieves the database encoding.
1.729 +
1.730 +@param aDbHandle Database handle
1.731 +@param aDbName Attached database name or KNullDesC for the main database
1.732 +@param aEncoding An output parameter where the encoding type will be stored (as text)
1.733 +
1.734 +@return KErrNone, Operation completed successfully;
1.735 + KErrNoMemory, Out of memory;
1.736 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.737 +
1.738 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.739 +
1.740 +@internalComponent
1.741 +*/
1.742 +TInt DbEncoding(sqlite3* aDbHandle, const TDesC& aDbName, TDes8& aEncoding)
1.743 + {
1.744 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.745 + return RetrievePragmaValue(aDbHandle, aDbName, KEncodingPragma, aEncoding);
1.746 + }
1.747 +
1.748 +/**
1.749 +Retrieves the database free pages count.
1.750 +
1.751 +@param aDbHandle Database handle
1.752 +@param aDbName Attached database name or KNullDesC for the main database
1.753 +@param aPageCount An output parameter where the free pages count will be stored
1.754 +
1.755 +@return KErrNone, Operation completed successfully;
1.756 + KErrNoMemory, Out of memory;
1.757 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.758 +
1.759 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.760 +
1.761 +@internalComponent
1.762 +*/
1.763 +TInt DbFreePageCount(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aPageCount)
1.764 + {
1.765 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.766 + return RetrievePragmaValue(aDbHandle, aDbName, KFreePageCountPragma, aPageCount);
1.767 + }
1.768 +
1.769 +/**
1.770 +Retrieves the current vacuum mode of the database.
1.771 +
1.772 +@param aDbHandle Database handle
1.773 +@param aDbName Attached database name or KNullDesC for the main database
1.774 +@param aVacuumMode An output parameter where the current vacuum mode will be stored
1.775 +
1.776 +@return KErrNone, Operation completed successfully;
1.777 + KErrNoMemory, Out of memory;
1.778 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.779 +
1.780 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.781 +
1.782 +@internalComponent
1.783 +*/
1.784 +TInt DbVacuumMode(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aVacuumMode)
1.785 + {
1.786 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.787 + return RetrievePragmaValue(aDbHandle, aDbName, KVacuumModePragma, aVacuumMode);
1.788 + }
1.789 +
1.790 +static TBool IsCompactTimeLimitReached(TUint32 aStartTicks, TUint32 aCurrTicks, TInt aMaxTime)
1.791 + {
1.792 + __ASSERT_DEBUG(aMaxTime > 0, __SQLPANIC2(ESqlPanicBadArgument));
1.793 + TInt64 tickDiff64 = (TInt64)aCurrTicks - (TInt64)aStartTicks;
1.794 + if(tickDiff64 < 0)
1.795 + {
1.796 + tickDiff64 = KMaxTUint32 + tickDiff64 + 1;
1.797 + }
1.798 + static TInt freq = 0;
1.799 + TInt err = KErrNone;
1.800 + if(freq == 0)
1.801 + {
1.802 + err = HAL::Get(HAL::EFastCounterFrequency, freq);
1.803 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, ISCOMPACTTIMELIMITREACHED, "0;IsCompactTimeLimitReached;fast counter frequency=%d;err=%d", freq, err));
1.804 + }
1.805 + if(err == KErrNone && freq > 0)
1.806 + {
1.807 + const TInt KMicroSecIn1Sec = 1000000;
1.808 + const TInt KMicroSecIn1Ms = 1000;
1.809 + TInt64 usDiff64 = (tickDiff64 * KMicroSecIn1Sec) / freq;
1.810 + if(usDiff64 > aMaxTime * KMicroSecIn1Ms)
1.811 + {
1.812 + return ETrue;
1.813 + }
1.814 + }
1.815 + return EFalse;
1.816 + }
1.817 +
1.818 +/**
1.819 +Compacts the database.
1.820 +
1.821 +@param aDbHandle Database handle.
1.822 +@param aPageCount Count of the free database pages to be removed from the file.
1.823 +@param aProcessedPageCount Output parameter. How many pages actually have been removed from the file.
1.824 +@param aMaxTime The max allowed time in milliseconds for the compact operation.
1.825 + If aMaxTime is zero, then aPageCount pages will be removed regardless the time.
1.826 +
1.827 +@return KErrNone, Operation completed successfully;
1.828 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.829 +
1.830 +@panic SqlDb 4 In _DEBUG mode if aPageCount is negative
1.831 +@panic SqlDb 4 In _DEBUG mode if aMaxTime is negative
1.832 +@panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
1.833 +
1.834 +@internalComponent
1.835 +*/
1.836 +TInt DbCompact(sqlite3* aDbHandle, const TDesC& aDbName, TInt aPageCount, TInt& aProcessedPageCount, TInt aMaxTime)
1.837 + {
1.838 + SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, DBCOMPACT_ENTRY, "Entry;0x%X;DbCompact;aDbName=%S;aPageCount=%d;aMaxTime=%d", (TUint)aDbHandle, __SQLPRNSTR(aDbName), aPageCount, aMaxTime));
1.839 + __ASSERT_DEBUG(aPageCount >= 0, __SQLPANIC2(ESqlPanicBadArgument));
1.840 + __ASSERT_DEBUG(aMaxTime >= 0, __SQLPANIC2(ESqlPanicBadArgument));
1.841 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.842 + TBuf8<KMaxFileName> dbName;
1.843 + if(!UTF16ToUTF8(aDbName, dbName))
1.844 + {
1.845 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, DBCOMPACT_EXIT1, "Exit;0x%X;DbCompact;err=KErrGeneral", (TUint)aDbHandle));
1.846 + return KErrGeneral;
1.847 + }
1.848 + TBuf8<KMaxFileName + sizeof(KIncrementalVacuumPragma) + 1> sql;
1.849 + if(dbName == KNullDesC8)
1.850 + {
1.851 + sql.Format(KIncrementalVacuumPragma, &KMainDb8, aPageCount);
1.852 + }
1.853 + else
1.854 + {
1.855 + sql.Format(KIncrementalVacuumPragma, &dbName, aPageCount);
1.856 + }
1.857 + //Currently there is no way to check how many pages have been compacted without executing a "PRAGMA freelist_count"
1.858 + //statement, if sqlite3_exec() is used.
1.859 + //So, instead of calling sqlite3_exec(), the function prepares and executes the "PRAGMA incremental_vacuum(N)"
1.860 + //statement using sqlite3_step() and counts the steps, because each step compacts one page.
1.861 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.862 + sqlite3_stmt* stmtHandle = NULL;
1.863 + const char* stmtTail = NULL;
1.864 + aProcessedPageCount = 0;
1.865 + //sqlite3_prepare_v2() expects parameter #3 to be one of the following:
1.866 + // - byte length of the sql statement (parameter #2), excluding terminating zero;
1.867 + // - negative value - the sql statement (parameter #2) is zero-terminated;
1.868 + TInt err = sqlite3_prepare_v2(aDbHandle, (const char*)sql.Ptr(), sql.Length() - sizeof(TUint8), &stmtHandle, &stmtTail);
1.869 + __ASSERT_DEBUG(err == SQLITE_OK ? !stmtTail || User::StringLength((const TUint8*)stmtTail) == 0 : !stmtHandle, __SQLPANIC2(ESqlPanicInternalError));
1.870 + if(stmtHandle) //stmtHandle can be NULL for statements like this: ";".
1.871 + {
1.872 + if(err == SQLITE_OK)
1.873 + {
1.874 + TUint32 startTicks = 0;
1.875 + if(aMaxTime > 0)
1.876 + {
1.877 + startTicks = User::FastCounter();
1.878 + }
1.879 +
1.880 + while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)
1.881 + {
1.882 + ++aProcessedPageCount;
1.883 + if(aMaxTime > 0 && IsCompactTimeLimitReached(startTicks, User::FastCounter(), aMaxTime))
1.884 + {
1.885 + err = SQLITE_DONE;//The statement execution did not complete because of the time limit
1.886 + break;
1.887 + }
1.888 + }
1.889 +
1.890 + if(err == SQLITE_ERROR) //It may be "out of memory" problem
1.891 + {
1.892 + err = sqlite3_reset(stmtHandle);
1.893 + __ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
1.894 + }
1.895 + }
1.896 + (void)sqlite3_finalize(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
1.897 + }
1.898 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.899 + if(err == KSqlAtEnd)
1.900 + {
1.901 + err = KErrNone;
1.902 + }
1.903 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, DBCOMPACT_EXIT2, "Exit;0x%X;DbCompact;aProcessedPageCount=%d;err=%d", (TUint)aDbHandle, aProcessedPageCount, err));
1.904 + return err;
1.905 + }
1.906 +
1.907 +/**
1.908 +Finalizes the statement handle.
1.909 +Although the function can return an error, it is ok not to check the returned error,
1.910 +because sqlite3_finalize() fails only if invalid statement handle is passed as an argument.
1.911 +
1.912 +@return KErrNone, Operation completed successfully;
1.913 + Other system-wide error codes or SQL errors of ESqlDbError type.
1.914 +
1.915 +@internalComponent
1.916 +*/
1.917 +TInt FinalizeStmtHandle(sqlite3_stmt* aStmtHandle)
1.918 + {
1.919 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, FINALIZESTMTHANDLE_ENTRY, "Entry;0x%X;FinalizeStmtHandle;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
1.920 + TInt err = KErrNone;
1.921 + if(aStmtHandle)
1.922 + {
1.923 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.924 + err = sqlite3_finalize(aStmtHandle);
1.925 + err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.926 + }
1.927 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, FINALIZESTMTHANDLE_EXIT, "Exit;0;FinalizeStmtHandle;err=%d", err));
1.928 + return err;
1.929 + }