FCL/sf/os/persistentdata: comparison persistentstorage/sql/SRC/Server/SqlSrvDatabase.cpp

equal deleted inserted replaced

-:0d6db0a14001
+:3256212fc81f
 #include "SqlSrvStatement.h"
 #include "SqlUtil.h"			//Panic codes, Sql2OsErrCode()
 #include "SqlSrvUtil.h"			//Global server functions
 #include "SqlCompact.h"
 #include "SqlSrvResourceProfiler.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "SqlSrvDatabaseTraces.h"
+#endif
+#include "SqlTraceDef.h"
 //
 // The following macro disables the creation/loading of the settings table.
 // It is for internal testing purposes only!
 //
 _LIT(KCacheSizePragma,	"PRAGMA \"%S\".cache_size=%d\x0");
 _LIT(KPageSizePragma,	"PRAGMA \"%S\".page_size=%d\x0");
 _LIT(KAutoVacuumPragma,	"PRAGMA \"%S\".auto_vacuum=%d\x0");
 //_LIT(KPersist, "persist");
 //_LIT(KPersistentJournalPragma, "PRAGMA \"%S\".journal_mode=%S\x0");
+_LIT(KJournalSizeLimitPragma, "PRAGMA \"%S\".journal_size_limit=%d\x0");
 ////////////////////////////////////////////////////////
 //"LIKE" - user defined function name
 _LIT8(KStrLikeFuncName,  "LIKE\x0");
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 //The function will panic with panic code 7 in _DEBUG mode if iKey member of aLeft or
 //aRight argument is NULL.
 static TInt Compare(const TSqlAttachDbPair& aLeft, const TSqlAttachDbPair& aRight)
 	{
-	__SQLASSERT(aLeft.iKey != NULL && aRight.iKey != NULL, ESqlPanicInternalError);
+	__ASSERT_DEBUG(aLeft.iKey != NULL && aRight.iKey != NULL, __SQLPANIC2(ESqlPanicInternalError));
 	return ::CompareNoCase8(TPtrC8(aLeft.iKey), TPtrC8(aRight.iKey));
 	}
 //Local function, used for comparing TSqlCompactDbPair objects.
 //(TSqlCompactDbPair structure represents type of the objects, members
 //
 //The function will panic with panic code 7 in _DEBUG mode if iKey member of aLeft or
 //aRight argument is NULL.
 static TInt Compare2(const TSqlCompactDbPair& aLeft, const TSqlCompactDbPair& aRight)
 	{
-	__SQLASSERT(aLeft.iKey != NULL && aRight.iKey != NULL, ESqlPanicInternalError);
+	__ASSERT_DEBUG(aLeft.iKey != NULL && aRight.iKey != NULL, __SQLPANIC2(ESqlPanicInternalError));
 	return ::CompareNoCase(*aLeft.iKey, *aRight.iKey);
 	}
 //Creates/opens database file (database file name in aFileData parameter) and initializes aDbHandle parameter.
 //The database will be created either with UTF-16 or UTF-8 encoding, depending on the
 	if(aFileData.ConfigParams().iDbEncoding == TSqlSrvConfigParams::EEncUtf8)
 		{
 		TBuf8<KMaxFileName + 1> fileNameZ;
 		if(!::UTF16ZToUTF8Z(aFileData.FileNameZ(), fileNameZ))
 			{
-			__SQLLEAVE(KErrGeneral);
+			__SQLLEAVE2(KErrGeneral);
 			}
-		__SQLLEAVE_IF_ERROR(::CreateDbHandle8(fileNameZ, aDbHandle));
+		__SQLLEAVE_IF_ERROR2(::CreateDbHandle8(fileNameZ, aDbHandle));
 		}
 	else
 		{
-		__SQLLEAVE_IF_ERROR(::CreateDbHandle16(aFileData.FileNameZ(), aDbHandle));
+		__SQLLEAVE_IF_ERROR2(::CreateDbHandle16(aFileData.FileNameZ(), aDbHandle));
 		}
 	}
 //LoadAttachedDbSecurityPolicyLC() creates a new CSqlSecurityPolicy object and initializes it with the
 //security policies read from the attached database file, which name is in aFileData parameter.
 //The created database security policy object is placed in the cleanup stack.
 //The caller is responsible for destroying the returned database security policy object.
 //The function is used to read the security policy of the main database.
 static CSqlSecurityPolicy* LoadDbSecurityPolicyLC(sqlite3* aDbHandle)
 	{
-	__SQLASSERT(aDbHandle != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 	//Create new database security policy object and initialize it with a default security policy
 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysFail);
 	CSqlSecurityPolicy* dbPolicy = CSqlSecurityPolicy::NewLC(defaultPolicy);
 	//Read the security policies.
 	TSqlDbSysSettings dbSysSettings(aDbHandle);
 //CreateStrCopyLC() makes a copy of aSrc string and places it in the cleanup stack.
 //aSrc is expected to be UTF8 encoded, zero terminated string.
 //The function panics in _DEBUG mode if aSrc is NULL.
 static TUint8* CreateStrCopyLC(const TUint8* aSrc)
 	{
-	__SQLASSERT(aSrc != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aSrc != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 	TInt len = User::StringLength(aSrc) + 1;
 	TUint8* copy = new (ELeave) TUint8[len];
 	Mem::Copy(copy, aSrc, len);
 	CleanupStack::PushL(copy);
 	return copy;
 //EnableAuthorizer() function is used to reenable the authorizer callback
 //during the stack cleanup.
 static void EnableAuthorizer(void* aAuthorizerDisabled)
 	{
-	__SQLASSERT(aAuthorizerDisabled != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aAuthorizerDisabled != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 	TBool* authorizerDisabled = static_cast <TBool*> (aAuthorizerDisabled);
 	*authorizerDisabled = EFalse;
 	}
 //Used by DbFileCleanup()
 //DbFileCleanup() is used to close and delete the database file during the stack cleanup, if
 //CSqlSrvDatabase's ConstructL() method(s) leave (when creating a new database file).
 static void DbFileCleanup(void* aDbFileCleanup)
 	{
-	__SQLASSERT(aDbFileCleanup != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aDbFileCleanup != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 	TDbFileCleanup* dbFileCleanup = static_cast <TDbFileCleanup*> (aDbFileCleanup);
 	dbFileCleanup->Cleanup();
 	}
 //Executes "PRAGMA" SQL statement + INTEGER value.
 // aDbName - "main" or the attached database name
 //This function is used for setting "cache_size", "page_size", "auto_vacuum" pragmas.
 //During the call the authorizer will be disabled.
 static TInt ExecPragma(sqlite3* aDbHandle, TBool& aAuthorizerDisabled, const TDesC& aPragma, TInt aValue, const TDesC& aDbName = KMainDb16)
 	{
-	__SQLASSERT(aDbHandle != NULL, ESqlPanicBadArgument);
+__SQLTRACE_INTERNALSEXPR(TPtrC pragmaprnptr(aPragma.Left(aPragma.Length() - 1)));
+	SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, EXECPRAGMA_ENTRY, "Entry;0;ExecPragma;sqlite3*=0x%X;aPragma=%S;aValue=%d;aDbName=%S", (TUint)aDbHandle, __SQLPRNSTR(pragmaprnptr), aValue, __SQLPRNSTR(aDbName)));
+	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 	TBuf<KMaxFileName + 64> pragmaSql;//(KMaxFileName + 64) characters buffer length is enough for the longest possible PRAGMA statement
 	pragmaSql.Format(aPragma, &aDbName, aValue);
 	TBool authorizerDisabledState = aAuthorizerDisabled;
 	aAuthorizerDisabled	= ETrue;
 	TInt err = DbExecStmt16(aDbHandle, pragmaSql);
 	aAuthorizerDisabled = authorizerDisabledState;
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, EXECPRAGMA_EXIT, "Exit;0;ExecPragma;sqlite3*=0x%X;err=%d", (TUint)aDbHandle, err));
 	return err;
+	}
+//The journal size limit is set to be at lest 16 pages and no less than 64 Kb.
+static void SetJournalSizeLimitL(sqlite3* aDbHandle, TBool& aAuthorizerDisabled, TInt aPageSize, const TDesC& aDbName = KMainDb16)
+	{
+	__ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
+	if(aPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet)
+		{
+		__SQLLEAVE_IF_ERROR2(DbPageSize(aDbHandle, aDbName, aPageSize));
+		}
+	const TInt KPageMultiplier = 16;
+	const TInt KDefaultJournalSizeLimit = 64 * 1024;
+	const TInt KMaxJournalSizeLimit = 512 * 1024;
+	const TInt KJournalSizeLimit = Min((aPageSize * KPageMultiplier), KMaxJournalSizeLimit);
+	if(KJournalSizeLimit > KDefaultJournalSizeLimit)
+		{
+		__SQLLEAVE_IF_ERROR2(::ExecPragma(aDbHandle, aAuthorizerDisabled, KJournalSizeLimitPragma, KJournalSizeLimit));
+		}
 	}
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////   CSqlSrvDatabase class    /////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 @panic SqlDb 4 In _DEBUG mode if aFileData does not refer to a secure database file name.
 @panic SqlDb 4 In _DEBUG mode if aSecurityPolicy is NULL.
 */
 CSqlSrvDatabase* CSqlSrvDatabase::CreateSecureL(const TSqlSrvFileData& aFileData, CSqlSecurityPolicy* aSecurityPolicy)
 	{
-	__SQLASSERT(aFileData.IsSecureFileNameFmt(), ESqlPanicBadArgument);
+	SQL_TRACE_INTERNALS(OstTrace0(TRACE_INTERNALS, CSQLSRVDATABASE_CREATESECUREL_ENTRY, "Entry;0;CSqlSrvDatabase::CreateSecureL"));
-	__SQLASSERT(aSecurityPolicy != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aFileData.IsSecureFileNameFmt(), __SQLPANIC2(ESqlPanicBadArgument));
+	__ASSERT_DEBUG(aSecurityPolicy != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 	if(!::SqlServer().SecurityInspector().Check(aSecurityPolicy->DbPolicy(RSqlSecurityPolicy::ESchemaPolicy)))
 		{
 		//The caller has no "SCHEMA" policy. Then the client is not given a permission to create the database.
 		//Delete aSecurityPolicy since no database object is going to be created and the security policy object
 		//won't be put in the security policies map.
 		delete aSecurityPolicy;
-		__SQLLEAVE(KErrPermissionDenied);
+		__SQLLEAVE2(KErrPermissionDenied);
 		}
 	//What does happen with aSecurityPolicy instance?
 	// If the database is created successfully, then a lookup will be made in the security policies map.
 	// (the security policies map contains reference counted security policies)
 	//    If the same security policy already exists in the map, then aSecurityPolicy will be deleted.
 	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();
 	CleanupStack::Pop(aSecurityPolicy);
 	CleanupStack::PushL(self);
 	self->ConstructCreateSecureL(aFileData, aSecurityPolicy);
 	CleanupStack::Pop(self);
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CREATESECUREL_EXIT, "Exit;0x%X;CSqlSrvDatabase::CreateSecureL;sqlite3*=0x%X", (TUint)self, (TUint)self->iDbHandle));
 	return self;
 	}
 /**
 Creates new CSqlSrvDatabase instance which creates and manages new SQL database.
 @panic SqlDb 4 In _DEBUG mode if aFileData refers to a secure database file name.
 */
 CSqlSrvDatabase* CSqlSrvDatabase::CreateL(const TSqlSrvFileData& aFileData)
 	{
-	__SQLASSERT(!aFileData.IsSecureFileNameFmt(), ESqlPanicBadArgument);
+	SQL_TRACE_INTERNALS(OstTrace0(TRACE_INTERNALS, CSQLSRVDATABASE_CREATEL_ENTRY, "Entry;0;CSqlSrvDatabase::CreateL"));
+	__ASSERT_DEBUG(!aFileData.IsSecureFileNameFmt(), __SQLPANIC2(ESqlPanicBadArgument));
 	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();
 	CleanupStack::PushL(self);
 	self->ConstructCreateL(aFileData);
 	CleanupStack::Pop(self);
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CREATEL_EXIT, "Exit;0x%X;CSqlSrvDatabase::CreateL;sqlite3*=0x%X", (TUint)self, (TUint)self->iDbHandle));
 	return self;
 	}
 /**
 Creates new CSqlSrvDatabase instance which opens and manages an existing SQL database.
 @see CSqlSecurityPolicy
 @see TSqlSrvFileData::SetFromHandleL()
 */
 CSqlSrvDatabase* CSqlSrvDatabase::OpenL(const TSqlSrvFileData& aFileData)
 	{
+	SQL_TRACE_INTERNALS(OstTrace0(TRACE_INTERNALS, CSQLSRVDATABASE_OPENL_ENTRY, "Entry;0;CSqlSrvDatabase::OpenL"));
 	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();
 	CleanupStack::PushL(self);
 	aFileData.IsSecureFileNameFmt() ? self->ConstructOpenSecureL(aFileData) : self->ConstructOpenL(aFileData);
 	CleanupStack::Pop(self);
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_OPENL_EXIT, "Exit;0x%X;CSqlSrvDatabase::OpenL;sqlite3*=0x%X", (TUint)self, (TUint)self->iDbHandle));
 	return self;
 	}
 /**
 Cleans up the allocated for the database connection memory and other resources.
 */
 CSqlSrvDatabase::~CSqlSrvDatabase()
 	{
-SQLPROFILER_DB_CLOSE((TUint)iDbHandle);
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CSQLSRVDATABASE2_ENTRY, "Entry;0x%X;CSqlSrvDatabase::~CSqlSrvDatabase;sqlite3*=0x%X", (TUint)this, (TUint)iDbHandle));
 	TSqlCompactDbMapIterator compactDbIt(iCompactDbMap);
 	TSqlCompactDbPair compactDbPair;
 	while(compactDbIt.Next(compactDbPair))
 		{
-__SQLASSERT(compactDbPair.iData, ESqlPanicInvalidObj);
+	   __ASSERT_DEBUG(compactDbPair.iData, __SQLPANIC2(ESqlPanicInvalidObj));
 		::SqlServer().Compactor().ReleaseEntry(*compactDbPair.iData);
 		}
 	iCompactDbMap.Close();
 	//If iSecureDbName is not NULL, the current CSqlSrvDatabase object operates on a secure database.
 	//The database security policy has to be removed from the security policy map.
 // the code there "expects" that is the first time when a "c:[11111111]b.db" entry is added to iSecurityMap.
 TSqlAttachDbMapIterator it(iAttachDbMap);
 TSqlAttachDbPair attachDbPair;
 while(it.Next(attachDbPair))
 {
-__SQLASSERT(attachDbPair.iData, ESqlPanicInvalidObj);
+__ASSERT_DEBUG(attachDbPair.iData, __SQLPANIC2(ESqlPanicInvalidObj));
 ::SqlServer().SecurityMap().Remove(attachDbPair.iData);
 }
 	iAttachDbMap.Close();
 	::CloseDbHandle(iDbHandle);
+	SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_CSQLSRVDATABASE2_EXIT, "Exit;0x%X;CSqlSrvDatabase::~CSqlSrvDatabase", (TUint)this));
 	}
 /**
 Initializes CSqlSrvDatabase data memebers with their default values.
 Note that the function may also leave with some other database specific
 errors categorised as ESqlDbError, and other system-wide error codes.
 */
 void CSqlSrvDatabase::CreateNewDbFileL(const TSqlSrvFileData& aFileData)
 	{
+	__SQLTRACE_INTERNALSVAR(TPtrC fname = aFileData.FileName());
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CREATENEWDBFILEL, "0x%x;CSqlSrvDatabase::CreateNewDbFileL;fname=%S", (TUint)this, __SQLPRNSTR(fname)));
 	if(::FileExists(aFileData.Fs(), aFileData.FileName()))
 		{
 		__SQLLEAVE(KErrAlreadyExists);
 		}
 	TDbFileCleanup dbFileCleanup(aFileData, iDbHandle);
 @see TSqlSrvFileData
 @see TSqlSrvFileData::SetFromHandleL()
 */
 void CSqlSrvDatabase::OpenExistingDbFileL(const TSqlSrvFileData& aFileData)
 	{
+	__SQLTRACE_INTERNALSVAR(TPtrC fname = aFileData.FileName());
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_OPENEXISTINGDBFILEL, "0x%x;CSqlSrvDatabase::OpenExistingDbFileL;fname=%S", (TUint)this, __SQLPRNSTR(fname)));
 	if(!aFileData.ContainHandles())
 		{//This check is valid only if the database is outside application's private data cage
 		if(!::FileExists(aFileData.Fs(), aFileData.FileName()))
 			{
 			__SQLLEAVE(KErrNotFound);
 @see TSqlSrvFileData
 */
 void CSqlSrvDatabase::AttachDbL(const TSqlSrvFileData& aFileData, const TDesC& aDbName)
 	{
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_ATTACHDBL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::AttachDbL;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbName)));
 	if(!aFileData.ContainHandles())
 		{//This check is valid only if the database is outside application's private data cage
 		if(!::FileExists(aFileData.Fs(), aFileData.FileName()))
 			{
 			__SQLLEAVE(KErrNotFound);
 					}
 				}
 			__SQLLEAVE(err);
 			}
 		}
+	SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_ATTACHDBL_EXIT, "Exit;0x%X;CSqlSrvDatabase::AttachDbL", (TUint)this));
 	}
 /**
 Attaches a secure database to the existing connection.
 @see CSqlServer
 @see CSqlSrvDatabase
 */
 void CSqlSrvDatabase::DetachDbL(const TDesC& aDbName)
 	{
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_DETACHDBL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::DetachDbL;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbName)));
 	TInt err = FinalizeAttachedDb(aDbName);
 	if(err == KErrNone)
 		{
 		TRAP_IGNORE(RemoveFromMapsL(aDbName));
 		}
 	else
 		{
 		__SQLLEAVE(err);
 		}
+	SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_DETACHDBL_EXIT, "Exit;0x%X;CSqlSrvDatabase::DetachDbL", (TUint)this));
 	}
 /**
 Calculates and returns the database size.
 	{
 	iAuthorizerDisabled	= ETrue;
 	CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
 	TInt pageCount = 0;
 	__SQLLEAVE_IF_ERROR(::DbPageCount(iDbHandle, aDbName, pageCount));
-	__SQLASSERT(pageCount >= 0, ESqlPanicInternalError);
+	__ASSERT_DEBUG(pageCount >= 0, __SQLPANIC(ESqlPanicInternalError));
 	CleanupStack::PopAndDestroy();
 	return (TInt64)pageCount * PageSizeL(aDbName);
 	}
 /**
 	iAuthorizerDisabled	= ETrue;
 	CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
 	TInt freePageCount = 0;
 	__SQLLEAVE_IF_ERROR(::DbFreePageCount(iDbHandle, aDbName, freePageCount));
 	CleanupStack::PopAndDestroy();
-	__SQLASSERT(freePageCount >= 0, ESqlPanicInternalError);
+	__ASSERT_DEBUG(freePageCount >= 0, __SQLPANIC(ESqlPanicInternalError));
 	return (TInt64)freePageCount * PageSizeL(aDbName);
 	}
 /**
 Collects information regarding the current cache size, page, size, encoding, etc. and puts the values
 @leave The function may leave with some database specific errors categorised as ESqlDbError,
 	   and other system-wide error codes.
 */
 TInt CSqlSrvDatabase::CompactL(TInt aSize, const TDesC& aDbName)
 	{
-	__SQLASSERT(aSize > 0 || aSize == RSqlDatabase::EMaxCompaction, ESqlPanicBadArgument);
+	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_COMPACTL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::CompactL;aSize=%d;aDbName=%S", (TUint)this, aSize, __SQLPRNSTR(aDbName)));
+	__ASSERT_DEBUG(aSize > 0 || aSize == RSqlDatabase::EMaxCompaction, __SQLPANIC(ESqlPanicBadArgument));
 	TInt pageSize = PageSizeL(aDbName);//PageSizeL() will disable/enable the authorizer
 	TInt pageCount = KMaxTInt;
 	if(aSize > 0)
 		{//64-bit calculations to avoid the overflow in case if (aSize + pageSize) >= KMaxTInt.
 		pageCount = (TInt64)((TInt64)aSize + pageSize - 1) / pageSize;
 		iAuthorizerDisabled	= ETrue;
 		CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
 		__SQLLEAVE_IF_ERROR(::DbCompact(iDbHandle, aDbName, pageCount, pageCount));
 		CleanupStack::PopAndDestroy();
 		}
+	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_COMPACTL_EXIT, "Exit;0x%X;CSqlSrvDatabase::CompactL;pageCount=%d;pageSize=%d", (TUint)this, pageCount, pageSize));
 	return pageCount * pageSize;
 	}
 /**
 This structure is used in case if the InitAttachedDbL() execution fails and the
 @internalComponent
 */
 void CSqlSrvDatabase::AttachCleanup(void* aCleanup)
 	{
 	TAttachCleanup* cleanup = reinterpret_cast <TAttachCleanup*> (aCleanup);
-	__SQLASSERT(cleanup != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(cleanup != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 	(void)cleanup->iSelf.FinalizeAttachedDb(cleanup->iDbName);
 	}
 /**
 Forms and executes "ATTACH DATABASE" SQL statement.
 		}
 	else
 		{
 		//No, it is not in the map. Read the security policies from the security policies tables and
 		//insert a new item in the map.
-		__SQLASSERT(aMapKey != NULL, ESqlPanicInternalError);
+		__ASSERT_DEBUG(aMapKey != NULL, __SQLPANIC(ESqlPanicInternalError));
 		aMapKey = ::CreateStrCopyLC(aMapKey);
 		CSqlSecurityPolicy* securityPolicy = aAttachedDb ? ::LoadAttachedDbSecurityPolicyLC(aFileData) :
 		                                                   ::LoadDbSecurityPolicyLC(iDbHandle);
-__SQLASSERT(!::SqlServer().SecurityMap().Entry(aMapKey), ESqlPanicObjExists);
+	    __ASSERT_DEBUG(!::SqlServer().SecurityMap().Entry(aMapKey), __SQLPANIC2(ESqlPanicObjExists));
 		__SQLLEAVE_IF_ERROR(::SqlServer().SecurityMap().Insert(aMapKey, securityPolicy));
 		CleanupStack::Pop(2);//iSecurityMap owns aMapKey and securityPolicy objects
 		aSecurityPolicy = securityPolicy;
 		}
-	__SQLASSERT(aMapKey != NULL, ESqlPanicInternalError);
+	__ASSERT_DEBUG(aMapKey != NULL, __SQLPANIC(ESqlPanicInternalError));
-	__SQLASSERT(aSecurityPolicy != NULL, ESqlPanicInternalError);
+	__ASSERT_DEBUG(aSecurityPolicy != NULL, __SQLPANIC(ESqlPanicInternalError));
 	}
 /**
 Removes attached secure database entries from the maps.
 @see CSqlServer
 @see CSqlSrvDatabase
 */
 void CSqlSrvDatabase::RemoveFromMapsL(const TDesC& aDbName)
 	{
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_REMOVEFROMMAPSL, "0x%X;CSqlSrvDatabase::RemoveFromMapsL;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbName)));
 	TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));
 	if(!::UTF16ToUTF8Z(aDbName, ptr))
 		{
 		__SQLLEAVE(KErrGeneral);
 		}
 @see RSqlAttachDbMap
 @see CSqlSrvDatabase
 */
 void CSqlSrvDatabase::InsertInAttachDbMapL(const TDesC& aDbFileName, const TDesC& aDbName)
 	{
+	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_INSERTINATTACHDBMAPL, "0x%X;CSqlSrvDatabase::InsertInAttachDbMapL;aDbFileName=%S;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbFileName), __SQLPRNSTR(aDbName)));
 	//Convert aDbName to UTF8, zero-terminated name
 	TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));
 	if(!::UTF16ToUTF8Z(aDbName, ptr))
 		{
 		__SQLLEAVE(KErrGeneral);
 		}
 	const TUint8* mapKey = ::CreateStrCopyLC(iFileNameBuf);
 	const TUint8* mapData = SecurityMapKeyL(aDbFileName);
 	mapData = ::CreateStrCopyLC(mapData);
-__SQLASSERT(!iAttachDbMap.Entry(mapKey), ESqlPanicObjExists);
+	__ASSERT_DEBUG(!iAttachDbMap.Entry(mapKey), __SQLPANIC(ESqlPanicObjExists));
 	__SQLLEAVE_IF_ERROR(iAttachDbMap.Insert(mapKey, mapData));
 	CleanupStack::Pop(2);//iAttachDbMap owns mapKey amd mapData.
 	}
 /**
 @panic SqlDb 7 In _DEBUG mode if aFileData does not refer to a r/w database file.
 */
 void CSqlSrvDatabase::ProcessSettingsL(const TSqlSrvFileData& aFileData, const TDesC& aDbName)
 	{
-	__SQLASSERT(!aFileData.IsReadOnly(), ESqlPanicInternalError);
+	__ASSERT_DEBUG(!aFileData.IsReadOnly(), __SQLPANIC(ESqlPanicInternalError));
 #if !defined(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)
 	//Make the journal file persistent - done by SQLite automatically because the locking mode is EXCLUSIVE
 	//__SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KPersistentJournalPragma, KPersist, aDbName));
 	//Load the current settings
 	TFileName storedCollationDllName;
 	__SQLLEAVE_IF_ERROR(::DbVacuumMode(iDbHandle, aDbName, currVacuumMode));
 	//currVacuumMode == ESqliteVacuumOff ==> This is a database created not by the SQL server
 	TSqlCompactionMode compactionMode = currVacuumMode == ESqliteVacuumOff ? ESqlCompactionManual : ESqlCompactionNotSet;
 	TSqlDbSysSettings dbSettings(iDbHandle);
 	dbSettings.LoadSettingsL(aDbName, storedCollationDllName, storedDbConfigFileVer, compactionMode);
-	__SQLASSERT(currVacuumMode == ESqliteVacuumOff ? compactionMode == ESqlCompactionManual : 1, ESqlPanicInternalError);
+	__ASSERT_DEBUG(currVacuumMode == ESqliteVacuumOff ? compactionMode == ESqlCompactionManual : 1, __SQLPANIC(ESqlPanicInternalError));
 	if(aFileData.ContainHandles() && aFileData.IsCreated())
 		{
 		compactionMode = aFileData.ConfigParams().iCompactionMode;
 		if(compactionMode == ESqlCompactionNotSet)
 			{
 	{
 	TSqlDbSysSettings dbSettings(iDbHandle);
 	//Check whether reindexing is necessary
 	if(::SqlServer().CollationDllName().CompareF(aStoredCollationDllName) != 0)
 		{
+		SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_APPLYCONFIGUPDATES2L, "0x%X;CSqlSrvDatabase::ApplyConfigUpdatesL;Reindex db;aStoredCollationDllName=%S;aDbName=%S", (TUint)this, __SQLPRNSTR(aStoredCollationDllName), __SQLPRNSTR(aDbName)));
 		dbSettings.ReindexDatabaseL(aDbName, ::SqlServer().CollationDllName());
 		}
 	//Perform any necessary configuration file updates to the database.
 	//We do not want failures here to cause the database to fail
 	//to be opened and so any leave error is TRAPed and ignored
 	//(the error is logged in _DEBUG mode)
 	TRAPD(err, dbSettings.ConfigureDatabaseL(aStoredDbConfigFileVersion, aFileData, aDbName));
 	if(KErrNone != err)
 		{
-		__SQLLOG_ERR(_L("SQLLOG: CSqlSrvDatabase::ApplyConfigUpdatesL() - ConfigureDatabaseL() failed with error code %d"), err);
+		SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_APPLYCONFIGUPDATESL, "0x%X;CSqlSrvDatabase::ApplyConfigUpdatesL;ConfigureDatabaseL() failed with error code %d", (TUint)this, err));
 		}
 	}
 /**
 Sets the "cache size" and "page size" parameter values, if their values are valid.
 @param aLogicalDbName Parameter with default value of KNullDesC. If aLogicalDbName length is not 0, then the
 "cache_size" pragma will be executed on the attached database with aLogicalDbName name.
 */
 void CSqlSrvDatabase::SetConfigL(const TSqlSrvConfigParams& aConfigParams, TBool aSetPageSize, const TDesC& aLogicalDbName)
 	{
-	__SQLASSERT(aConfigParams.iPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iPageSize >= 0, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aConfigParams.iPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iPageSize >= 0, __SQLPANIC(ESqlPanicBadArgument));
-	__SQLASSERT(aConfigParams.iCacheSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iCacheSize >= 0, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aConfigParams.iCacheSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iCacheSize >= 0, __SQLPANIC(ESqlPanicBadArgument));
 	if(aSetPageSize && aConfigParams.iPageSize != TSqlSrvConfigParams::KConfigPrmValueNotSet)
 		{
 		__SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KPageSizePragma, aConfigParams.iPageSize));
 		}
 	const TDesC& logicalDbName = aLogicalDbName.Length() > 0 ? aLogicalDbName : KMainDb16;
+	::SetJournalSizeLimitL(iDbHandle, iAuthorizerDisabled, aConfigParams.iPageSize, logicalDbName);
 	//Setting the cache size.
 	//Step 1: Check if aConfigParams.iCacheSize value is set. If it is set, then use it.
 	if(aConfigParams.iCacheSize != TSqlSrvConfigParams::KConfigPrmValueNotSet)
 		{
 		__SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KCacheSizePragma, aConfigParams.iCacheSize, logicalDbName));
 	else
 		{
 	//Step 2: aConfigParams.iCacheSize value is not set. Then check if aConfigParams.iSoftHeapLimitKb value is set.
 		if(aConfigParams.iSoftHeapLimitKb != TSqlSrvConfigParams::KConfigPrmValueNotSet)
 			{
-			__SQLASSERT(aConfigParams.iSoftHeapLimitKb >= TSqlSrvConfigParams::KMinSoftHeapLimitKb &&
+			__ASSERT_DEBUG(aConfigParams.iSoftHeapLimitKb >= TSqlSrvConfigParams::KMinSoftHeapLimitKb &&
-			            aConfigParams.iSoftHeapLimitKb <= TSqlSrvConfigParams::KMaxSoftHeapLimitKb, ESqlPanicInternalError);
+			            aConfigParams.iSoftHeapLimitKb <= TSqlSrvConfigParams::KMaxSoftHeapLimitKb, __SQLPANIC(ESqlPanicInternalError));
 	//Step 3: aConfigParams.iSoftHeapLimitKb value is set. Then use it to calculate the cache size. But we need the page size first.
 //        aLogicalDbName is used instead of logicalDbName because PageSizeL() if called with non-zero length name,
 	//        "thinks" it is the main database name. KMainDb16 will be interpreted as an attached database name.
 		TInt pageSize = PageSizeL(aLogicalDbName);
 	//Step 4: Calculate the cache size.
 @panic SqlDb 4 In _DEBUG mode if aCompactionMode parameter value is invalid.
 */
 void CSqlSrvDatabase::InitCompactionL(TSqlCompactionMode aCompactionMode, TInt aFreePageThresholdKb,
 									  const TDesC& aDbFileName, TSqliteVacuumMode aCurrentVacuumMode, const TDesC& aDbName)
 	{
-	__SQLASSERT(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, __SQLPANIC(ESqlPanicBadArgument));
-	__SQLASSERT(aCurrentVacuumMode == ESqliteVacuumOff || aCurrentVacuumMode == ESqliteVacuumAuto ||
+	__ASSERT_DEBUG(aCurrentVacuumMode == ESqliteVacuumOff || aCurrentVacuumMode == ESqliteVacuumAuto ||
-			    aCurrentVacuumMode == ESqliteVacuumIncremental, ESqlPanicBadArgument);
+			    aCurrentVacuumMode == ESqliteVacuumIncremental, __SQLPANIC(ESqlPanicBadArgument));
-	__SQLASSERT(aFreePageThresholdKb >= 0, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aFreePageThresholdKb >= 0, __SQLPANIC(ESqlPanicBadArgument));
 	TSqliteVacuumMode newSqliteVacuumMode = aCompactionMode == ESqlCompactionAuto ? ESqliteVacuumAuto : ESqliteVacuumIncremental;
 	if(aCurrentVacuumMode == ESqliteVacuumOff)
 		{
 		newSqliteVacuumMode = ESqliteVacuumOff;
 		}
 @see CSqlCompactor
 @see RSqlCompactDbMap
 */
 void CSqlSrvDatabase::NewCompactEntryL(TInt aFreePageThresholdKb, const TDesC& aDbFileName, const TDesC& aDbName)
 	{
+	SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, CSQLSRVDATABASE_NEWCOMPACTENTRYL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::NewCompactEntryL;aFreePageThresholdKb=%d;aDbFileName=%S;aDbName=%S", (TUint)this, aFreePageThresholdKb, __SQLPRNSTR(aDbFileName), __SQLPRNSTR(aDbName)));
 	TSqlCompactSettings settings;
 	settings.iFreePageThresholdKb = aFreePageThresholdKb;
 	::SqlServer().Compactor().AddEntryL(aDbFileName, settings);
 	TInt err = KErrNoMemory;
 	HBufC* key = aDbName.Alloc();
 	HBufC* data = aDbFileName.Alloc();
 	if(key && data)
 		{
-	    __SQLASSERT(!iCompactDbMap.Entry(key), ESqlPanicObjExists);
+	    __ASSERT_DEBUG(!iCompactDbMap.Entry(key), __SQLPANIC(ESqlPanicObjExists));
 		err = iCompactDbMap.Insert(key, data);//returns the index of the new entry
 		}
 	if(err < 0) //If either "key" or "data" or both is NULL, then "err" is KErrNoMemory and the next "if" will be executed.
 		{
 		delete data;
 		delete key;
 		::SqlServer().Compactor().ReleaseEntry(aDbFileName);
 		}
+	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_NEWCOMPACTENTRYL_EXIT, "Exit;0x%X;CSqlSrvDatabase::NewCompactEntryL;err=%d", (TUint)this, err));
 	__SQLLEAVE_IF_ERROR(err);
 	}
 /**
 Removes database (identified by its logical name) from the compactor.
 		{
 		if(::CompareNoCase(*compactDbPair.iKey, aDbName) == 0)
 			{
 			::SqlServer().Compactor().ReleaseEntry(*compactDbPair.iData);
 			iCompactDbMap.Remove(compactDbPair.iKey);
+			SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_RELEASECOMPACTENTRY, "0x%X;CSqlSrvDatabase::ReleaseCompactEntry", (TUint)this));
 			break;
 			}
 		}
 	}
 @param aCleanup A pointer to the CSqlSrvDatabase object
 */
 void CSqlSrvDatabase::CompactCleanup(void* aCleanup)
 	{
 	CSqlSrvDatabase* self = reinterpret_cast <CSqlSrvDatabase*> (aCleanup);
-	__SQLASSERT(self != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(self != NULL, __SQLPANIC2(ESqlPanicBadArgument));
 self->ReleaseCompactEntry(KMainDb16);
 	}
 /**
 Retrieves the database page size.
 	iAuthorizerDisabled	= ETrue;
 	CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
 	TInt pageSize = 0;
 	__SQLLEAVE_IF_ERROR(::DbPageSize(iDbHandle, aDbName, pageSize));
 	CleanupStack::PopAndDestroy();
-	__SQLASSERT(pageSize > 0, ESqlPanicInternalError);
+	__ASSERT_DEBUG(pageSize > 0, __SQLPANIC(ESqlPanicInternalError));
 	if(aDbName == KNullDesC)
 		{
 		iPageSize = pageSize;
 		}
 	return pageSize;
 @panic SqlDb 4 In _DEBUG mode if aSecurityPolicy is NULL.
 */
 void CSqlSrvDatabase::ConstructCreateSecureL(const TSqlSrvFileData& aFileData, CSqlSecurityPolicy* aSecurityPolicy)
 	{
-	__SQLASSERT(aSecurityPolicy != NULL, ESqlPanicBadArgument);
+	__ASSERT_DEBUG(aSecurityPolicy != NULL, __SQLPANIC(ESqlPanicBadArgument));
 	//Insert a new item in the security policies map.
 	CleanupStack::PushL(aSecurityPolicy);
 	const TUint8* mapKey = SecurityMapKeyL(aFileData.FileName());
 	mapKey = ::CreateStrCopyLC(mapKey);
-__SQLASSERT(!::SqlServer().SecurityMap().Entry(mapKey), ESqlPanicObjExists);
+	__ASSERT_DEBUG(!::SqlServer().SecurityMap().Entry(mapKey), __SQLPANIC(ESqlPanicObjExists));
 	__SQLLEAVE_IF_ERROR(::SqlServer().SecurityMap().Insert(mapKey, aSecurityPolicy));
 	CleanupStack::Pop(2);//iSecurityMap owns mapKey and aSecurityPolicy.
 	iSecureDbName = mapKey;
 	iSecurityPolicy = aSecurityPolicy;
 	//
 	DoCommonConstructCreateL(aFileData, ETrue);
 // - installs the user-defined functions
 // - installs collations
 //If the method fails and the error is not KErrAlreadyExists, the database file will be closed and deleted.
 void CSqlSrvDatabase::DoCommonConstructCreateL(const TSqlSrvFileData& aFileData, TBool aSecureDb)
 	{
-	__SQLASSERT(!iDbHandle, ESqlPanicInternalError);
+	__ASSERT_DEBUG(!iDbHandle, __SQLPANIC(ESqlPanicInternalError));
-	__SQLASSERT(aSecureDb ? iSecurityPolicy != NULL : ETrue, ESqlPanicInternalError);
+	__ASSERT_DEBUG(aSecureDb ? iSecurityPolicy != NULL : ETrue, __SQLPANIC(ESqlPanicInternalError));
 	CreateNewDbFileL(aFileData);
 	TDbFileCleanup dbFileCleanup(aFileData, iDbHandle);
 	CleanupStack::PushL(TCleanupItem(&DbFileCleanup, &dbFileCleanup));
 	//Make the journal file persistent - done by SQLite automatically because the locking mode is EXCLUSIVE
 	//::ExecPragma(iDbHandle, iAuthorizerDisabled, KPersistentJournalPragma, KPersist);

changeset 41	3256212fc81f
parent 22	a7ba600cb39d
child 51	7d4490026038