sl@0: // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <e32debug.h>
sl@0: #include <hal.h>
sl@0: #include <sqldb.h>
sl@0: #include "sqlite3.h"
sl@0: #include "SqlSrvStatementUtil.h"
sl@0: #include "SqlAssert.h"
sl@0: #include "SqlSrvUtil.h"
sl@0: #include "SqlUtil.h"
sl@0: #include "SqliteSymbian.h"		//sqlite3SymbianLastOsError()
sl@0: #include "OstTraceDefinitions.h"
sl@0: #include "SqlSrvResourceProfiler.h"
sl@0: #ifdef OST_TRACE_COMPILER_IN_USE
sl@0: #include "SqlSrvStatementUtilTraces.h"
sl@0: #endif
sl@0: #include "SqlTraceDef.h"
sl@0: 
sl@0: //The database names in all statements are quoted to avoid the "sql injection" threat.
sl@0: _LIT8(KPageCountPragma, "PRAGMA \"%S\".page_count\x0");
sl@0: _LIT8(KPageSizePragma,  "PRAGMA \"%S\".page_size\x0");
sl@0: _LIT8(KCacheSizePragma,  "PRAGMA \"%S\".cache_size\x0");
sl@0: _LIT8(KEncodingPragma,  "PRAGMA \"%S\".encoding\x0");
sl@0: _LIT8(KFreePageCountPragma, "PRAGMA \"%S\".freelist_count\x0");
sl@0: _LIT8(KVacuumModePragma, "PRAGMA \"%S\".auto_vacuum\x0");
sl@0: _LIT8(KIncrementalVacuumPragma, "PRAGMA \"%S\".incremental_vacuum(%d)\x0");
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Calls sqlite3_open16() to create or open database file with aFileNameZ.
sl@0: //aFileNameZ is UTF16 encoded, zero-terminated.
sl@0: //The function returns system-wide errors or database specific errors.
sl@0: //The function may panic with code 7 in _DEBUG mode - internal error: the created database handle is NULL.
sl@0: TInt CreateDbHandle16(const TDesC& aFileNameZ, sqlite3*& aDbHandle)
sl@0: 	{
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	TInt err = sqlite3_open16(aFileNameZ.Ptr(), &aDbHandle);
sl@0: 	__ASSERT_DEBUG(err == SQLITE_OK ? aDbHandle != NULL : ETrue, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	if(err == SQLITE_OK)
sl@0: 		{
sl@0: 		(void)sqlite3_extended_result_codes(aDbHandle, 0);
sl@0: 		}
sl@0: 	//Get the return error code now, because the next "if" may destroy it.
sl@0: 	TInt rc = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	if(err != SQLITE_OK)
sl@0: 		{//Yes, it is possible error code != SQLITE_OK and aDbHandle != NULL.
sl@0: 		CloseDbHandle(aDbHandle);
sl@0: 		aDbHandle = NULL;
sl@0: 		}
sl@0: 	return rc;
sl@0: 	}
sl@0: 
sl@0: //Calls sqlite3_open() to create or open database file with aFileNameZ.
sl@0: //aFileNameZ is UTF8 encoded, zero-terminated.
sl@0: //The function returns system-wide errors or database specific errors.
sl@0: //The function may panic with code 7 in _DEBUG mode - internal error: the created database handle is NULL.
sl@0: TInt CreateDbHandle8(const TDesC8& aFileNameZ, sqlite3*& aDbHandle)
sl@0: 	{
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	TInt err = sqlite3_open((const char *) aFileNameZ.Ptr(), &aDbHandle);
sl@0: 	__ASSERT_DEBUG(err == SQLITE_OK ? aDbHandle != NULL : ETrue, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	if(err == SQLITE_OK)
sl@0: 		{
sl@0: 		(void)sqlite3_extended_result_codes(aDbHandle, 0);
sl@0: 		}
sl@0: 	//Get the return error code now, because the next "if" may destroy it.
sl@0: 	TInt rc = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	if(err != SQLITE_OK)
sl@0: 		{//Yes, it is possible error code != SQLITE_OK and aDbHandle != NULL.
sl@0: 		CloseDbHandle(aDbHandle);
sl@0: 		aDbHandle = NULL;
sl@0: 		}
sl@0: 	return rc;
sl@0: 	}
sl@0: 	
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /////                     16-bit and 8-bit SQL statements execution upon completion                        ////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //16-bit SQL statement execution.
sl@0: //
sl@0: //aSql - zero-terminated string
sl@0: //
sl@0: //Prepares the supplied as an argument (aSql) 16-bit SQL statement and executes it.
sl@0: //If aSql argument contains more than one SQL statements, separated with ';', then
sl@0: //the function panics in _DEBUG mode (panic code 7).
sl@0: //
sl@0: //The function panics in debug mode (panic code 2) if aDbHandle is NULL.
sl@0: //
sl@0: //If the function completes successfully, it returns SQLITE_ROW or SQLITE_DONE.
sl@0: //If the function fails then it returns one of the SQLITE error codes.
sl@0: static TInt DoSingleStmtExec16(sqlite3 *aDbHandle, const TDesC16& aSql)
sl@0: 	{
sl@0:     __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
sl@0:     __ASSERT_DEBUG(aSql.Length() > 0 ? (TInt)aSql[aSql.Length() - 1] == 0 : ETrue, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	const void* stmtTail = NULL;
sl@0:     //sqlite3_prepare16_v2() expects parameter #3 to be one of the following:
sl@0:     // - byte length of the sql statement (parameter #2), excluding terminating zero;
sl@0:     // - negative value - the sql statement (parameter #2) is zero-terminated;
sl@0: 	TInt err = sqlite3_prepare16_v2(aDbHandle, aSql.Ptr(), aSql.Length() * sizeof(TUint16) - sizeof(TUint16), &stmtHandle, &stmtTail);
sl@0: 	__ASSERT_DEBUG(err == SQLITE_OK ? !stmtTail || User::StringLength((const TUint16*)stmtTail) == 0 : !stmtHandle, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	if(stmtHandle)	//stmtHandle can be NULL for statements like this: ";".
sl@0: 		{
sl@0: 		if(err == SQLITE_OK)
sl@0: 			{
sl@0: 			while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)
sl@0: 				{
sl@0: 				}
sl@0: 			if(err == SQLITE_ERROR)	//It may be "out of memory" problem
sl@0: 				{
sl@0: 				err = sqlite3_reset(stmtHandle);
sl@0: 				__ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 				}
sl@0: 			}
sl@0: 		(void)sqlite3_finalize(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: This function searches aString argument for ';' occurences.
sl@0: Every time when it finds a ';' character, the function places a zero character right after the ';' and
sl@0: tests the just created, zero-terminated substring if it is a comlpete SQL statement.
sl@0: 
sl@0: If it is a SQL statement, the function replaces the found ';' character with zero and returns the just created
sl@0: zero-terminated substring.Also the function modifies aString argument to point right after the found
sl@0: SQL string. If it is not SQL statement, the function will continue the searching.
sl@0: 
sl@0: If there is no ';' inside aString argument, the function returns the same string as a return result and
sl@0: modifies aString argument - sets it to TPtr(NULL, 0, 0).
sl@0: 
sl@0: The function expects aString argument to be zero-terminated.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TPtrC GetFirstSqlStmt(TPtr& aString)
sl@0: 	{
sl@0: 	const TChar KDelimitier(';');
sl@0: 	TPtr originalStr(aString);
sl@0: 	TPtr str(const_cast <TUint16*> (aString.Ptr()), aString.Length(), aString.Length());
sl@0: 	TInt afterDelimitierPos = 0;
sl@0: 	TInt pos;
sl@0: 	while((pos = str.Locate(KDelimitier) + 1) > 0 && pos < str.Length())
sl@0: 		{
sl@0: 		//There is a possibility that the string, which terminates with the found ';' character, is a SQL statement.
sl@0: 		//Zero terminate the string placing a zero right after the ';' character and test it using sqlite3_complete16().
sl@0: 		//If it is not a SQL string, restore the original character and continue searching.
sl@0: 		afterDelimitierPos += pos;
sl@0: 		TChar ch = aString[afterDelimitierPos];
sl@0: 		aString[afterDelimitierPos] = 0;
sl@0: 		TInt res = sqlite3_complete16(aString.Ptr());
sl@0: 		aString[afterDelimitierPos] = ch;
sl@0: 		if(res)
sl@0: 			{
sl@0: 			str.Set(const_cast <TUint16*> (aString.Ptr()), afterDelimitierPos, afterDelimitierPos);	
sl@0: 			//Replace the found ';' character with 0.
sl@0: 			str[afterDelimitierPos - 1] = 0;
sl@0: 			aString.Set(const_cast <TUint16*> (aString.Ptr()) + afterDelimitierPos, aString.Length() - afterDelimitierPos, aString.Length() - afterDelimitierPos);
sl@0: 			return str;
sl@0: 			}
sl@0: 		str.Set(const_cast <TUint16*> (str.Ptr()) + pos, str.Length() - pos, str.Length() - pos);	
sl@0: 		}
sl@0: 	//aString argument does not contain valid SQL statement or there is no ';' character inside aString.
sl@0: 	//Set aString to TPtr(NULL, 0, 0) and return the original string.
sl@0: 	aString.Set(NULL, 0, 0);
sl@0: 	str.Set(originalStr);
sl@0: 	return str;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Executes one or more 16-bit SQL statements. SQL statements of any kind can be executed, but the 
sl@0: method won't return any record(s) if the SQL statement type is "SELECT".
sl@0: If the SQL statement(s) contains one or more parameters, the method will execute it giving the parameters
sl@0: default NULL values.
sl@0: 
sl@0: @param aDbHandle Database handle. Not NULL.
sl@0: @param aSqlStmt String containing one or more 16-bit SQL statements, separated with ';'. Zero-terminated string.
sl@0: 				Note: The ExecL() call can modify the content of aSqlStmt argument.
sl@0: 
sl@0: @return KErrNone, Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 		KSqlErrGeneral, Syntax error. A text message describing the problem can be obtained calling
sl@0: 						RSqlDatabase::LastErrorMessage();
sl@0: 						Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 4 In _DEBUG mode if aSqlStmt is not zero-terminated string
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbExecStmt16(sqlite3* aDbHandle, TDes16& aSqlStmt)
sl@0: 	{
sl@0:     __SQLTRACE_INTERNALSEXPR(TPtrC sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT16_ENTRY, "Entry;0x%X;DbExecStmt16;sql=%S", (TUint)aDbHandle, __SQLPRNSTR(sqlprnptr)));
sl@0: 	
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aSqlStmt.Length() > 0 ? (TInt)aSqlStmt[aSqlStmt.Length() - 1] == 0: ETrue, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	
sl@0: 	TInt err = SQLITE_DONE;
sl@0: 	//Execute SQL statement(s)
sl@0: 	//16-bit SQL string - no sqlite3_exec16() function, so the execution is made with 
sl@0: 	//sqlite3_prepare16_v2() and sqlite3_step() functions.
sl@0: 	TPtr16 sql(const_cast <TUint16*> (aSqlStmt.Ptr()), aSqlStmt.Length(), aSqlStmt.Length());
sl@0: 	TPtrC firstSqlStmt(KNullDesC);
sl@0: 	while(err == SQLITE_DONE && sql.Length() > 1) //"> 1" because it is a zero terminated string
sl@0: 		{
sl@0: 		firstSqlStmt.Set(GetFirstSqlStmt(sql));
sl@0:         SQLPROFILER_SQL16_PRINT((TUint)aDbHandle, firstSqlStmt.Left(firstSqlStmt.Length() - 1), EFalse);
sl@0: 		err = ::DoSingleStmtExec16(aDbHandle, firstSqlStmt);
sl@0: 		}
sl@0: 		
sl@0: 	err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	if(err == KSqlAtEnd)
sl@0: 		{
sl@0: 		err = KErrNone;	
sl@0: 		}
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT16_EXIT, "Exit;0x%X;DbExecStmt16;err=%d", (TUint)aDbHandle, err));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Executes one or more 8-bit SQL statements. SQL statements of any kind can be executed, but the 
sl@0: method won't return any record(s) if the SQL statement type is "SELECT".
sl@0: If the SQL statement(s) contains one or more parameters, the method will execute it giving the parameters
sl@0: default NULL values.
sl@0: 
sl@0: @param aDbHandle Database handle. Not NULL.
sl@0: @param aSqlStmt String containing one or more 8-bit SQL statements, separated with ';'. Zero-terminated string.
sl@0: 
sl@0: @return KErrNone, Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 		KSqlErrGeneral, Syntax error. A text message describing the problem can be obtained calling
sl@0: 						RSqlDatabase::LastErrorMessage();
sl@0: 		Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 4 In _DEBUG mode if aSqlStmt is not zero-terminated string
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbExecStmt8(sqlite3* aDbHandle, const TDesC8& aSqlStmt)
sl@0: 	{
sl@0:     __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
sl@0: 	__SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT8_ENTRY, "Entry;0x%X;DbExecStmt8;sql=%s", (TUint)aDbHandle, __SQLPRNSTR8(sqlprnptr, des16prnbuf)));
sl@0:     
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aSqlStmt.Length() > 0 ? (TInt)aSqlStmt[aSqlStmt.Length() - 1] == 0: ETrue, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 
sl@0:     SQLPROFILER_SQL8_PRINT((TUint)aDbHandle, aSqlStmt.Left(aSqlStmt.Length() - 1), EFalse);
sl@0: 	
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	
sl@0: 	TInt err = sqlite3_exec(aDbHandle, reinterpret_cast <const char*> (aSqlStmt.Ptr()), NULL, NULL, NULL);
sl@0: 
sl@0: 	err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	__ASSERT_DEBUG(err != KSqlAtEnd, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, DBEXECSTMT8_EXIT, "Exit;0x%X;DbExecStmt8;err=%d", (TUint)aDbHandle, err));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /////                     16-bit and 8-bit SQL statement preparation                                      /////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Prepares 16-bit SQL statement, returning in aStmtHandle the statement handle and
sl@0: //setting aHasTail to true, if aStmt contains more than one sql statements.
sl@0: //aStmt - zero-terminated string.
sl@0: //Returns one of SQLITE error codes.
sl@0: static TInt DoPrepareStmt16(sqlite3* aDbHandle, const TDesC& aStmt, sqlite3_stmt** aStmtHandle, TBool& aHasTail)
sl@0: 	{
sl@0: 	const void* stmtTail = NULL;
sl@0:     //sqlite3_prepare16_v2() expects parameter #3 to be one of the following:
sl@0:     // - byte length of the sql statement (parameter #2), excluding terminating zero;
sl@0:     // - negative value - the sql statement (parameter #2) is zero-terminated;
sl@0: 	TInt err = sqlite3_prepare16_v2(aDbHandle, aStmt.Ptr(), aStmt.Length() * sizeof(TUint16) - sizeof(TUint16), aStmtHandle, &stmtTail);
sl@0: 	aHasTail = stmtTail && static_cast <const TUint16*> (stmtTail)[0] != 0;
sl@0: 	__ASSERT_DEBUG(err != SQLITE_OK ? !(*aStmtHandle) : ETrue, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	//(*aStmtHandle) is NULL for ";" statements, when err == SQLITE_OK. Since the server should not panic
sl@0: 	//that situation is handled later (not inside the assert above)
sl@0: 	return err;
sl@0: 	}
sl@0: 	
sl@0: //Prepares 8-bit SQL statement, returning in aStmtHandle the statement handle and
sl@0: //setting aHasTail to true, if aStmt contains more than one sql statements.
sl@0: //aStmt - zero-terminated string.
sl@0: //Returns one of SQLITE error codes.
sl@0: static TInt DoPrepareStmt8(sqlite3* aDbHandle, const TUint8* aStmt, sqlite3_stmt** aStmtHandle, TBool& aHasTail)
sl@0: 	{
sl@0: 	const char* stmtTail = NULL;
sl@0:     //sqlite3_prepare_v2() expects parameter #3 to be one of the following:
sl@0:     // - byte length of the sql statement (parameter #2), excluding terminating zero;
sl@0:     // - negative value - the sql statement (parameter #2) is zero-terminated;
sl@0: 	TInt err = sqlite3_prepare_v2(aDbHandle, reinterpret_cast <const char*> (aStmt), -1, aStmtHandle, &stmtTail);
sl@0: 	aHasTail = stmtTail && stmtTail[0] != 0;
sl@0: 	__ASSERT_DEBUG(err != SQLITE_OK ? !(*aStmtHandle) : ETrue, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	//(*aStmtHandle) is NULL for ";" statements, when err == SQLITE_OK. Since the server should not panic
sl@0: 	//that situation is handled later (not inside the assert above)
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: //This function accepts as arguments the SQLITE error code, 
sl@0: //"aHasTail" boolean flag set to true if the SQL string contains more than one SQL statement 
sl@0: //and the statement handle.
sl@0: //
sl@0: //It checks the arguments and returns an error if:
sl@0: // - aSqliteError != SQLITE_OK;
sl@0: // - aHasTail is true (possibly more than one SQL statement, separated with ";");
sl@0: // - aStmtHandle is NULL;
sl@0: //
sl@0: static TInt ProcessPrepareError(TInt aSqliteError, TBool aHasTail, sqlite3_stmt*& aStmtHandle)
sl@0: 	{
sl@0: 	if(aSqliteError != SQLITE_OK)
sl@0: 		{
sl@0: 		return ::Sql2OsErrCode(aSqliteError, sqlite3SymbianLastOsError());
sl@0: 		}
sl@0: 	else if(aHasTail || !aStmtHandle)
sl@0: 		{//Case 1:
sl@0: 		 // More than one SQL statement or the SQL string is "" or ";;;" or ";   ;; ;". 
sl@0: 		 // Report it as an error, because there is no statement handle.
sl@0: 		 //Case 2:
sl@0: 		 // Non-null aHasTail. In this case the SQL string contains more than one SQL statement.
sl@0: 		 // The statement handle is not null. The statement has to be finialized before reporting the error.
sl@0: 		(void)FinalizeStmtHandle(aStmtHandle);
sl@0: 		aStmtHandle = NULL;
sl@0: 		return KErrArgument;
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: //This function accepts as arguments the SQLITE error code, 
sl@0: //"aHasTail" boolean flag set to true if the SQL string contains more than one SQL statement 
sl@0: //and the statement handle.
sl@0: //
sl@0: //It checks the arguments and leaves if:
sl@0: // - aSqliteError != SQLITE_OK;
sl@0: // - aHasTail is true (possibly more than one SQL statement, separated with ";");
sl@0: // - aStmtHandle is NULL;
sl@0: //
sl@0: static void LeaveIfPrepareErrorL(TInt aSqliteError, TBool aHasTail, sqlite3_stmt* aStmtHandle)
sl@0: 	{
sl@0: 	__SQLLEAVE_IF_ERROR2(ProcessPrepareError(aSqliteError, aHasTail, aStmtHandle));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Prepares 16-bit aSqlStmt SQL statement.
sl@0: 
sl@0: @param aSqlStmt - zero-terminated string.
sl@0: 
sl@0: @leave KErrNoMemory, if there is no memory;
sl@0: 	   KErrArgument, if the SQL string contains more than one SQL statements;
sl@0: 	   One of the error codes in [KSqlErrGeneral..KSqlErrNotDb] range.
sl@0: 
sl@0: @return The prepared SQL statement handle.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: sqlite3_stmt* StmtPrepare16L(sqlite3* aDbHandle, const TDesC16& aSqlStmt)
sl@0: 	{
sl@0:     __SQLTRACE_INTERNALSEXPR(TPtrC sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE16L_ENTRY, "Entry;0x%X;StmtPrepare16L;sql=%S", (TUint)aDbHandle, __SQLPRNSTR(sqlprnptr)));	
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	TBool hasTail = EFalse;
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	TInt err = DoPrepareStmt16(aDbHandle, aSqlStmt, &stmtHandle, hasTail);
sl@0: 	LeaveIfPrepareErrorL(err, hasTail, stmtHandle);
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE16L_EXIT, "Exit;0x%X;StmtPrepare16L;stmtHandle=0x%X", (TUint)aDbHandle, (TUint)stmtHandle)); 
sl@0: 	return stmtHandle;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Prepares 8-bit aSqlStmt SQL statement.
sl@0: 
sl@0: @param aSqlStmt - zero-terminated string.
sl@0: 
sl@0: @leave KErrNoMemory, if there is no memory;
sl@0: 	   KErrArgument, if the SQL string contains more than one SQL statements;
sl@0: 	   One of the error codes in [KSqlErrGeneral..KSqlErrNotDb] range.
sl@0: 
sl@0: @return The prepared SQL statement handle.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt StmtPrepare8(sqlite3* aDbHandle, const TDesC8& aSqlStmt, sqlite3_stmt*& aStmtHandle)
sl@0: 	{
sl@0:     __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
sl@0: 	__SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE8_ENTRY, "Entry;0x%X;StmtPrepare8;sql=%s", (TUint)aDbHandle, __SQLPRNSTR8(sqlprnptr, des16prnbuf))); 
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	TBool hasTail = EFalse;
sl@0: 	TInt err = DoPrepareStmt8(aDbHandle, aSqlStmt.Ptr(), &aStmtHandle, hasTail);
sl@0: 	err = ProcessPrepareError(err, hasTail, aStmtHandle);
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, STMTPREPARE8_EXIT, "Exit;0x%X;StmtPrepare8;aStmtHandle=0x%X;err=%d", (TUint)aDbHandle, (TUint)aStmtHandle, err)); 
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Prepares 8-bit aSqlStmt SQL statement.
sl@0: 
sl@0: @param aSqlStmt - zero-terminated string.
sl@0: 
sl@0: @leave KErrNoMemory, if there is no memory;
sl@0: 	   KErrArgument, if the SQL string contains more than one SQL statements;
sl@0: 	   One of the error codes in [KSqlErrGeneral..KSqlErrNotDb] range.
sl@0: 
sl@0: @return The prepared SQL statement handle.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: sqlite3_stmt* StmtPrepare8L(sqlite3* aDbHandle, const TDesC8& aSqlStmt)
sl@0: 	{
sl@0:     __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aSqlStmt.Left(aSqlStmt.Length() - 1)));
sl@0: 	__SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE8L_ENTRY, "Entry;0x%X;StmtPrepare8L;sql=%s", (TUint)aDbHandle, __SQLPRNSTR8(sqlprnptr, des16prnbuf))); 
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	TBool hasTail = EFalse;
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	TInt err = DoPrepareStmt8(aDbHandle, aSqlStmt.Ptr(), &stmtHandle, hasTail);
sl@0: 	LeaveIfPrepareErrorL(err, hasTail, stmtHandle);
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTPREPARE8L_EXIT, "Exit;0x%X;StmtPrepare8L;stmtHandle=0x%X", (TUint)aDbHandle, (TUint)stmtHandle)); 
sl@0: 	return stmtHandle;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Executes upon completion the prepared SQL statement.
sl@0: 
sl@0: @param aStmtHandle Prepared statement handle
sl@0: 
sl@0: @return KSqlErrStmtExpired, Statement expired (if new functions or collating sequences are 
sl@0: 							registered or if an authorizer function is added or changed);
sl@0: 		KErrNoMemory, Out of memory. The statement will be reset;
sl@0: 		KErrNone, The reset operation completed successfully.							
sl@0: 
sl@0: @panic SqlDb 2 In _DEBUG mode. Invalid (NULL) statement handle.
sl@0: @panic SqlDb 7 In _DEBUG mode. SQLITE internal error. (SQLITE_ERROR, followed by a sqlite3_reset(), which returns SQLITE_OK)
sl@0: 
sl@0: @internalComponent
sl@0: */	
sl@0: TInt StmtExec(sqlite3_stmt* aStmtHandle)
sl@0: 	{
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTEXEC_ENTRY, "Entry;0x%X;StmtExec;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
sl@0: 	__ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
sl@0: 	
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 
sl@0: 	TInt err;
sl@0: 	while((err = sqlite3_step(aStmtHandle)) == SQLITE_ROW)
sl@0: 		{
sl@0: 		}
sl@0: 		
sl@0: 	if(err == SQLITE_ERROR)	//It may be "out of memory" problem
sl@0: 		{
sl@0: 		err = sqlite3_reset(aStmtHandle);
sl@0: 		__ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 		}
sl@0: 		
sl@0: 	err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	if(err == KSqlAtEnd)
sl@0: 		{
sl@0: 		err = KErrNone;	
sl@0: 		}
sl@0: 
sl@0: 	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));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Executes the SQL statement moving it to the next row if available.
sl@0: 
sl@0: @return KSqlErrStmtExpired Statement expired (if new functions or collating sequences are 
sl@0: 							registered or if an authorizer function is added or changed)
sl@0: @return KSqlAtRow, The next record data is ready for processing by the caller;
sl@0: 		KSqlAtEnd, No more record data;
sl@0: 		KSqlErrBusy, Database file is locked;
sl@0: 		KSqlErrGeneral, Run-time error. Next() should not be called anymore;
sl@0: 		KSqlErrMisuse, Next() called after KSqlAtEnd or KSqlErrGeneral returned by the previous Next() call;
sl@0: 		KErrNoMemory, Out of memory. The statement will be reset.
sl@0: 
sl@0: @panic SqlDb 2 In _DEBUG mode. Invalid (NULL) statement handle.
sl@0: @panic SqlDb 7 In _DEBUG mode. SQLITE internal error. (SQLITE_ERROR, followed by a sqlite3_reset(), which returns SQLITE_OK)
sl@0: 
sl@0: @internalComponent
sl@0: */	
sl@0: TInt StmtNext(sqlite3_stmt* aStmtHandle)
sl@0: 	{
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTNEXT_ENTRY, "Entry;0x%X;StmtNext;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
sl@0: 	__ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
sl@0: 	
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	
sl@0: 	TInt err = sqlite3_step(aStmtHandle);
sl@0: 	if(err == SQLITE_ERROR)	//It may be "out of memory" problem
sl@0: 		{
sl@0: 		err = sqlite3_reset(aStmtHandle);
sl@0: 		__ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 		}
sl@0: 	err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	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));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Resets the prepared SQL statement to its initial state and makes it ready to be executed again.
sl@0: Any SQL statement parameters that had values bound to them, retain their values.
sl@0: 
sl@0: @return KSqlErrStmtExpired, Statement expired (if new functions or collating sequences are 
sl@0: 							registered or if an authorizer function is added or changed);
sl@0: 		KErrNone, The reset operation completed successfully.							
sl@0: 
sl@0: @panic SqlDb 2 In _DEBUG mode. Invalid (NULL) statement handle.
sl@0: 
sl@0: @internalComponent
sl@0: */	
sl@0: TInt StmtReset(sqlite3_stmt* aStmtHandle)
sl@0: 	{
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, STMTRESET_ENTRY, "Entry;0x%X;StmtReset;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
sl@0: 	__ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
sl@0: 	
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	
sl@0: 	TInt err = sqlite3_reset(aStmtHandle);
sl@0: 	err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	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));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Prepares and executes PRAGMA statement and moves the statement cursor on the first row.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aPragmaSql Pragma sql statement
sl@0: @param aStmtHandle An output parameter where the statement handle will be stored
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: @panic SqlDb 4 In _DEBUG mode if aPragmaSql length is 0 or if the statement is not zero-terminated
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt PreRetrievePragmaValue(sqlite3* aDbHandle, const TDesC& aDbName, const TDesC8& aPragmaSql, sqlite3_stmt*& aStmtHandle)
sl@0: 	{
sl@0:     __SQLTRACE_INTERNALSEXPR(TPtrC8 sqlprnptr(aPragmaSql.Left(aPragmaSql.Length() - 1)));
sl@0: 	__SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, PRERETRIEVEPRAGMAVALUE_ENTRY, "Entry;0x%X;PreRetrievePragmaValue;aDbName=%S;aPragmaSql=%s", (TUint)aDbHandle, __SQLPRNSTR(aDbName), __SQLPRNSTR8(sqlprnptr, des16prnbuf)));
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aPragmaSql.Length() > 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aPragmaSql[aPragmaSql.Length() - 1] == 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	TBuf8<KMaxFileName> dbName;
sl@0: 	if(!UTF16ToUTF8(aDbName, dbName))
sl@0: 		{
sl@0: 		SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, PRERETRIEVEPRAGMAVALUE_EXIT1, "Exit;0x%X;PreRetrievePragmaValue;err=KErrGeneral", (TUint)aDbHandle));
sl@0: 		return KErrGeneral;
sl@0: 		}
sl@0: 	TBuf8<KMaxFileName + 64> sql;//64 characters is enough for the longest PRAGMA statement
sl@0: 	if(dbName == KNullDesC8)
sl@0: 		{
sl@0: 		sql.Format(aPragmaSql, &KMainDb8);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		sql.Format(aPragmaSql, &dbName);
sl@0: 		}
sl@0: 	aStmtHandle = NULL;
sl@0: 	TInt err = ::StmtPrepare8(aDbHandle, sql, aStmtHandle);
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		__ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC2(ESqlPanicInvalidObj));
sl@0: 		err = ::StmtNext(aStmtHandle);
sl@0: 		}
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, PRERETRIEVEPRAGMAVALUE_EXIT2, "Exit;0x%X;PreRetrievePragmaValue;aStmtHandle=0x%X;err=%d", (TUint)aDbHandle, (TUint)aStmtHandle, err));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Prepares and executes PRAGMA statement and retrieves the value of column 0 (the pragma value).
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aPragmaSql Pragma sql statement
sl@0: @param aPragmaValue An output parameter where the pragma value will be stored
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: @panic SqlDb 4 In _DEBUG mode if aPragmaSql length is 0 or if the statement is not zero-terminated
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt RetrievePragmaValue(sqlite3* aDbHandle, const TDesC& aDbName, const TDesC8& aPragmaSql, TInt& aPragmaValue)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aPragmaSql.Length() > 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aPragmaSql[aPragmaSql.Length() - 1] == 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	TInt err = PreRetrievePragmaValue(aDbHandle, aDbName, aPragmaSql, stmtHandle);
sl@0: 	if(err == KSqlAtRow)
sl@0: 		{
sl@0: 		aPragmaValue = sqlite3_column_int(stmtHandle, 0);
sl@0: 		err = aPragmaValue >= 0 ? KErrNone : KErrCorrupt;
sl@0: 		}
sl@0: 	(void)FinalizeStmtHandle(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Prepares and executes PRAGMA statement and retrieves the value of column 0 (the pragma value) as text.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aPragmaSql Pragma sql statement
sl@0: @param aPragmaValue An output parameter where the pragma value will be stored (as text)
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: @panic SqlDb 4 In _DEBUG mode if aPragmaSql length is 0 or if the statement is not zero-terminated
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt RetrievePragmaValue(sqlite3* aDbHandle, const TDesC& aDbName, const TDesC8& aPragmaSql, TDes8& aPragmaValue)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aPragmaSql.Length() > 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aPragmaSql[aPragmaSql.Length() - 1] == 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	TInt err = PreRetrievePragmaValue(aDbHandle, aDbName, aPragmaSql, stmtHandle);
sl@0: 	if(err == KSqlAtRow)
sl@0: 		{
sl@0: 		TPtrC8 ptr(sqlite3_column_text(stmtHandle, 0));
sl@0: 		aPragmaValue.Copy(ptr);
sl@0: 		err = KErrNone;
sl@0: 		}
sl@0: 	(void)FinalizeStmtHandle(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the database pages count.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aPageCount An output parameter where the database pages count will be stored
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbPageCount(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aPageCount)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	return RetrievePragmaValue(aDbHandle, aDbName, KPageCountPragma, aPageCount);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the database page size.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aPageSize An output parameter where the page size will be stored
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbPageSize(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aPageSize)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	return RetrievePragmaValue(aDbHandle, aDbName, KPageSizePragma, aPageSize);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the database cache size in pages.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aCacheSize An output parameter where the cache size will be stored
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbCacheSize(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aCacheSize)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	return RetrievePragmaValue(aDbHandle, aDbName, KCacheSizePragma, aCacheSize);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the database encoding.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aEncoding An output parameter where the encoding type will be stored (as text)
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbEncoding(sqlite3* aDbHandle, const TDesC& aDbName, TDes8& aEncoding)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	return RetrievePragmaValue(aDbHandle, aDbName, KEncodingPragma, aEncoding);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the database free pages count.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aPageCount An output parameter where the free pages count will be stored
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbFreePageCount(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aPageCount)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	return RetrievePragmaValue(aDbHandle, aDbName, KFreePageCountPragma, aPageCount);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the current vacuum mode of the database.
sl@0: 
sl@0: @param aDbHandle Database handle
sl@0: @param aDbName Attached database name or KNullDesC for the main database
sl@0: @param aVacuumMode An output parameter where the current vacuum mode will be stored
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 		KErrNoMemory, Out of memory;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbVacuumMode(sqlite3* aDbHandle, const TDesC& aDbName, TInt& aVacuumMode)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	return RetrievePragmaValue(aDbHandle, aDbName, KVacuumModePragma, aVacuumMode);
sl@0: 	}
sl@0: 
sl@0: static TBool IsCompactTimeLimitReached(TUint32 aStartTicks, TUint32 aCurrTicks, TInt aMaxTime)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aMaxTime > 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	TInt64 tickDiff64 = (TInt64)aCurrTicks - (TInt64)aStartTicks;
sl@0: 	if(tickDiff64 < 0)
sl@0: 		{
sl@0: 		tickDiff64 = KMaxTUint32 + tickDiff64 + 1;
sl@0: 		}
sl@0: 	static TInt freq = 0;
sl@0: 	TInt err = KErrNone;
sl@0: 	if(freq == 0)
sl@0: 		{
sl@0: 		err = HAL::Get(HAL::EFastCounterFrequency, freq);
sl@0: 		SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, ISCOMPACTTIMELIMITREACHED, "0;IsCompactTimeLimitReached;fast counter frequency=%d;err=%d", freq, err));
sl@0: 		}
sl@0: 	if(err == KErrNone && freq > 0)
sl@0: 		{
sl@0: 		const TInt KMicroSecIn1Sec = 1000000;
sl@0: 		const TInt KMicroSecIn1Ms = 1000;
sl@0: 		TInt64 usDiff64 = (tickDiff64 * KMicroSecIn1Sec) / freq;
sl@0: 		if(usDiff64 > aMaxTime * KMicroSecIn1Ms)
sl@0: 			{
sl@0: 			return ETrue;	
sl@0: 			}
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Compacts the database.
sl@0: 
sl@0: @param aDbHandle 			Database handle.
sl@0: @param aPageCount 			Count of the free database pages to be removed from the file.
sl@0: @param aProcessedPageCount	Output parameter. How many pages actually have been removed from the file.
sl@0: @param aMaxTime				The max allowed time in milliseconds for the compact operation.
sl@0: 							If aMaxTime is zero, then aPageCount pages will be removed regardless the time.
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @panic SqlDb 4 In _DEBUG mode if aPageCount is negative
sl@0: @panic SqlDb 4 In _DEBUG mode if aMaxTime is negative
sl@0: @panic SqlDb 7 In _DEBUG mode if aDbHandle is NULL
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt DbCompact(sqlite3* aDbHandle, const TDesC& aDbName, TInt aPageCount, TInt& aProcessedPageCount, TInt aMaxTime)
sl@0: 	{
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, DBCOMPACT_ENTRY, "Entry;0x%X;DbCompact;aDbName=%S;aPageCount=%d;aMaxTime=%d", (TUint)aDbHandle, __SQLPRNSTR(aDbName), aPageCount, aMaxTime));
sl@0: 	__ASSERT_DEBUG(aPageCount >= 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aMaxTime >= 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	TBuf8<KMaxFileName> dbName;
sl@0: 	if(!UTF16ToUTF8(aDbName, dbName))
sl@0: 		{
sl@0: 		SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, DBCOMPACT_EXIT1, "Exit;0x%X;DbCompact;err=KErrGeneral", (TUint)aDbHandle));
sl@0: 		return KErrGeneral;
sl@0: 		}
sl@0: 	TBuf8<KMaxFileName + sizeof(KIncrementalVacuumPragma) + 1> sql;
sl@0: 	if(dbName == KNullDesC8)
sl@0: 		{
sl@0: 		sql.Format(KIncrementalVacuumPragma, &KMainDb8, aPageCount);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		sql.Format(KIncrementalVacuumPragma, &dbName, aPageCount);
sl@0: 		}
sl@0: 	//Currently there is no way to check how many pages have been compacted without executing a "PRAGMA freelist_count"	
sl@0: 	//statement, if sqlite3_exec() is used. 
sl@0: 	//So, instead of calling sqlite3_exec(), the function prepares and executes the "PRAGMA incremental_vacuum(N)"
sl@0: 	//statement using sqlite3_step() and counts the steps, because each step compacts one page.
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	const char* stmtTail = NULL;
sl@0: 	aProcessedPageCount = 0;
sl@0: 	//sqlite3_prepare_v2() expects parameter #3 to be one of the following:
sl@0: 	// - byte length of the sql statement (parameter #2), excluding terminating zero;
sl@0: 	// - negative value - the sql statement (parameter #2) is zero-terminated;
sl@0: 	TInt err = sqlite3_prepare_v2(aDbHandle, (const char*)sql.Ptr(), sql.Length() - sizeof(TUint8), &stmtHandle, &stmtTail);
sl@0: 	__ASSERT_DEBUG(err == SQLITE_OK ? !stmtTail || User::StringLength((const TUint8*)stmtTail) == 0 : !stmtHandle, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	if(stmtHandle)	//stmtHandle can be NULL for statements like this: ";".
sl@0: 		{
sl@0: 		if(err == SQLITE_OK)
sl@0: 			{
sl@0: 			TUint32 startTicks = 0;
sl@0: 			if(aMaxTime > 0)
sl@0: 				{
sl@0: 				startTicks = User::FastCounter();
sl@0: 				}
sl@0: 			
sl@0: 			while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)
sl@0:                 {
sl@0:                 ++aProcessedPageCount;
sl@0:                 if(aMaxTime > 0 && IsCompactTimeLimitReached(startTicks, User::FastCounter(), aMaxTime))
sl@0:                     {
sl@0:                     err = SQLITE_DONE;//The statement execution did not complete because of the time limit
sl@0:                     break;  
sl@0:                     }
sl@0:                 }
sl@0: 			
sl@0: 			if(err == SQLITE_ERROR)  //It may be "out of memory" problem
sl@0:                 {
sl@0:                 err = sqlite3_reset(stmtHandle);
sl@0:                 __ASSERT_DEBUG(err != SQLITE_OK, __SQLPANIC2(ESqlPanicInternalError));
sl@0:                 }
sl@0: 			}
sl@0: 		(void)sqlite3_finalize(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
sl@0: 		}
sl@0: 	err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 	if(err == KSqlAtEnd)
sl@0: 		{
sl@0: 		err = KErrNone;	
sl@0: 		}
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, DBCOMPACT_EXIT2, "Exit;0x%X;DbCompact;aProcessedPageCount=%d;err=%d", (TUint)aDbHandle, aProcessedPageCount, err));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Finalizes the statement handle.
sl@0: Although the function can return an error, it is ok not to check the returned error,
sl@0: because sqlite3_finalize() fails only if invalid statement handle is passed as an argument.
sl@0: 
sl@0: @return KErrNone,     Operation completed successfully;
sl@0: 					  Other system-wide error codes or SQL errors of ESqlDbError type.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: TInt FinalizeStmtHandle(sqlite3_stmt* aStmtHandle)
sl@0: 	{
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, FINALIZESTMTHANDLE_ENTRY, "Entry;0x%X;FinalizeStmtHandle;aStmtHandle=0x%X", (TUint)sqlite3_db_handle(aStmtHandle), (TUint)aStmtHandle));
sl@0: 	TInt err = KErrNone;
sl@0: 	if(aStmtHandle)
sl@0: 		{
sl@0: 		(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 		err = sqlite3_finalize(aStmtHandle);
sl@0: 		err = ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
sl@0: 		}
sl@0: 	SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, FINALIZESTMTHANDLE_EXIT, "Exit;0;FinalizeStmtHandle;err=%d", err));
sl@0: 	return err;
sl@0: 	}