// Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "SqlSrvFileData.h"		//TSqlSrvFileData

#include "SqlSrvMain.h"			//CSqlServer

#include "SqlSrvAuthorizer.h"	//MSqlPolicyInspector

#include "SqlSrvDatabase.h"

#include "SqlSrvStatement.h"

#include "SqlUtil.h"			//Panic codes, Sql2OsErrCode()

#include "SqlSrvUtil.h"			//Global server functions

#include "SqlCompact.h"

#include "SqlSrvResourceProfiler.h"

//

// The following macro disables the creation/loading of the settings table.

// It is for internal testing purposes only!

// 

//    __SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__

// 

// This means that the database index will always be rebuilt when loaded by 

// by the server regardless of the current system collation/locale in use. 

// The benefit of enabling this macro is that a client can send PRAGMA 

// commands to the SQL server before any tables have been explicity created in 

// a NON-SECURE database (secure databases still automatically get a security 

// policy table).

//

// The macro is applied inside:  

//		CSqlSrvDatabase::StoreSettingsL

// 		CSqlSrvDatabase::ProcessSettingsL

// 

// We should inform the user at compile-time if this macro has been enabled:

#if defined(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)

#pragma message(">>> WARNING: Use of SYMBIAN_SETTINGS table has been disabled <<<")

#endif

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////        Local const data   ///////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

const char* KErrMsg1 = "Missing ESCAPE expression";

const char* KErrMsg2 = "ESCAPE expression must be a single character";

////////////////////////////////////////////////////////

//Attach/detach SQL statements (zero-terminated strings)

_LIT(KAttachDb, "ATTACH DATABASE :FileName AS :DbName\x0");

_LIT(KDetachDb, "DETACH DATABASE :DbName\x0");

////////////////////////////////////////////////////////

// Pragma SQL statements. The database names in all statements are quoted to avoid the "sql injection" threat.

// (At the moment there is no way to pass an invalid database name for these statements, because the database has to be attached

//  first and a parameter binding is used there. So, the quoting is just for safety and against changes in the future)

_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");

////////////////////////////////////////////////////////

//"LIKE" - user defined function name

_LIT8(KStrLikeFuncName,  "LIKE\x0");

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////        Local functions    ///////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Local function, used for comparing TSqlAttachDbPair objects.

//(TSqlAttachDbPair structure represents type of the objects, members

// of the map used for keeping the information regarding attached databases)

//

//Note that iKey members of aLeft and aRight function parameters are expected to be 

//UTF8 encoded, zero-terminated strings.

//

//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);

	return ::CompareNoCase8(TPtrC8(aLeft.iKey), TPtrC8(aRight.iKey));

	}

//Local function, used for comparing TSqlCompactDbPair objects.

//(TSqlCompactDbPair structure represents type of the objects, members

// of the map used for keeping the information regarding compacted databases)

//

//Note that iKey members of aLeft and aRight function parameters are expected to be 

//UTF16 encoded strings.

//

//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);

	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 

//TSqlSrvFileData::IsUTF16() property.

static void CreateDbHandleL(const TSqlSrvFileData& aFileData, sqlite3*& aDbHandle)

	{

	if(aFileData.ConfigParams().iDbEncoding == TSqlSrvConfigParams::EEncUtf8)

		{

		TBuf8<KMaxFileName + 1> fileNameZ;

		if(!::UTF16ZToUTF8Z(aFileData.FileNameZ(), fileNameZ))

			{

			__SQLLEAVE(KErrGeneral);	

			}

		__SQLLEAVE_IF_ERROR(::CreateDbHandle8(fileNameZ, aDbHandle));

		}

	else

		{

		__SQLLEAVE_IF_ERROR(::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 the destruction of the created and returned security policy object.

//This function is used to read the security policies of attached databases.

static CSqlSecurityPolicy* LoadAttachedDbSecurityPolicyLC(const TSqlSrvFileData& aFileData)

	{

	//Create new database security policy object and initialize it with a default security policy

	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysFail);

	CSqlSecurityPolicy* dbPolicy = CSqlSecurityPolicy::NewLC(defaultPolicy);

	//This is an attached  database and has to be opened

	sqlite3* dbHandle = NULL;

	CreateDbHandleL(aFileData, dbHandle);

	CleanupStack::PushL(TCleanupItem(&CloseDbCleanup, dbHandle));

	//Read the security policies.

	TSqlDbSysSettings dbSysSettings(dbHandle);

	dbSysSettings.LoadSecurityPolicyL(*dbPolicy);

	CleanupStack::PopAndDestroy();//TCleanupItem(&CloseDbCleanup, dbHandle)

	return dbPolicy;

	}

//LoadDbSecurityPolicyLC() creates a new CSqlSecurityPolicy object and initializes it with the 

//security policies read from the database file.

//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);

	//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);

	dbSysSettings.LoadSecurityPolicyL(*dbPolicy);

	return dbPolicy;

	}

//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);

	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);

	TBool* authorizerDisabled = static_cast <TBool*> (aAuthorizerDisabled);

	*authorizerDisabled = EFalse;

	}

//Used by DbFileCleanup()

NONSHARABLE_STRUCT(TDbFileCleanup)

	{

	TDbFileCleanup(const TSqlSrvFileData& aSqlSrvFileData, sqlite3*& aDbHandle) :

		iSqlSrvFileData(aSqlSrvFileData),

		iDbHandle(aDbHandle)

		{

		//aDbHandle can be NULL (it is a reference to a pointer and the pointer can be initialized later)

		}

	void Cleanup()

		{

		::CloseDbHandle(iDbHandle);//This operation also deletes the journal file

		iDbHandle = NULL;

		(void)iSqlSrvFileData.Fs().Delete(iSqlSrvFileData.FileName());

		}

private:

	const TSqlSrvFileData&	iSqlSrvFileData;

	sqlite3*& 				iDbHandle;

	};

//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);

	TDbFileCleanup* dbFileCleanup = static_cast <TDbFileCleanup*> (aDbFileCleanup);

	dbFileCleanup->Cleanup();

	}

//Executes "PRAGMA" SQL statement + INTEGER value.

//Pragma parameters:

// aValue - integer pragma value to be set;

// aPragma - pragma statement, the format is: ""PRAGMA <database name>.<parameter name>=%d\x0""

// 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);

	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;

	return err;

	}

//////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////   CSqlSrvDatabase class    /////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////   Object creation methods  /////////////////////////////////////////////

/**

Creates new CSqlSrvDatabase instance which creates and manages new secure SQL database.

@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

     			 file session reference and some other database file related properties.

				 The format of the name must be:

				 \<drive\>:\<[SID]database file name excluding the path\>.

				 "[SID]" refers to SID of the application which creates the database.

@param aSecurityPolicy The database security policies container. 

					   CSqlSrvDatabase instance stores the pointer in the security policy map,

					   if it does not exist there already. The security policies map is owned by the CSqlServer class.

@return A pointer to the created CSqlSrvDatabase instance.

@see CSqlServer

@see TSqlSrvFileData

@see MSqlPolicyInspector

@see RSqlSecurityMap

@see CSqlSecurityPolicy

@leave KErrNoMemory, an out of memory condition has occurred;

	   KErrArgument, if a system table name found in the security policies (aSecurityPolicy);

	   KErrAlreadyExists, the file already exists;

       KErrNotReady, the drive does not exist or is not ready;

       KErrInUse, the file is already open;

       KErrPermissionDenied, the client application does not satisfy the relevant database security policies.

                      Note that the function may also leave with some other database specific 

                      errors categorised as ESqlDbError, and other system-wide error codes.

@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);

	__SQLASSERT(aSecurityPolicy != NULL, 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);

		}

	//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.

	//                                          The reference counter of the found policy will be incremented.

	//    If aSecurityPolicy is not in the map, then it will be put in the map and removed

	//                                          from the map when CSqlSrvDatabase object is destroyed.

	//											(the "remove" operation decrements the security policy counter

	//											and destroys the policy if it reaches 0)

	//

	//The security policy map pair is:

	//{secure_db_name, reference_counted db_security_policy}

	//The security policy is reference counted, because the same database can be shared between one or more

	//connections (clients), in which case only a single, reference counted instance of the database security

	//policy is kept in the map.

	CleanupStack::PushL(aSecurityPolicy);

	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();

	CleanupStack::Pop(aSecurityPolicy);

	CleanupStack::PushL(self);

	self->ConstructCreateSecureL(aFileData, aSecurityPolicy);

	CleanupStack::Pop(self);

	return self;

	}

/**

Creates new CSqlSrvDatabase instance which creates and manages new SQL database.

@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

     			 file session reference and some other database file related properties.

@return A pointer to the created CSqlSrvDatabase instance.

@see CSqlServer

@see TSqlSrvFileData

@see MSqlPolicyInspector

@see RSqlSecurityMap

@see CSqlSecurityPolicy

@leave KErrNoMemory, an out of memory condition has occurred;

	   KErrArgument, the file name is a name of a secure database;

	   KErrAlreadyExists, the file already exists;

       KErrNotReady, the drive does not exist or is not ready;

       KErrInUse, the file is already open;

       KErrArgument, the file name refers to a secure database, but aSecurityPolicy is NULL;

                      Note that the function may also leave with some other database specific 

                      errors categorised as ESqlDbError, and other system-wide error codes.

@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);

	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();

	CleanupStack::PushL(self);

	self->ConstructCreateL(aFileData);

	CleanupStack::Pop(self);

	return self;

	}

/**

Creates new CSqlSrvDatabase instance which opens and manages an existing SQL database.

@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

     			 file session reference and some other database file related properties.

				 If this is a secure database, then the format of the name must be:

				 \<drive\>:\<[SID]database file name excluding the path\>.

				 If this is a non-secure database, then the file name has to be the full database file name.

				 "[SID]" refers to SID of the application which created the database.

				 If this is application's private database, then the format of aFileData is as it is described

				 in TSqlSrvFileData::SetFromHandleL() comments.

@return A pointer to the created CSqlSrvDatabase instance.

@leave KErrNoMemory, an out of memory condition has occurred;

       KErrNotReady, the drive does not exist or is not ready;

       KErrNotFound, the database file does not exist;

       KErrInUse, the file is already open;

       KErrPermissionDenied, the client application does not satisfy the relevant database security policies.

                      Note that the function may also leave with some other database specific 

                      errors categorised as ESqlDbError, and other system-wide error codes.

@see CSqlServer

@see TSqlSrvFileData

@see MSqlPolicyInspector

@see RSqlSecurityMap

@see CSqlSecurityPolicy

@see TSqlSrvFileData::SetFromHandleL()

*/

CSqlSrvDatabase* CSqlSrvDatabase::OpenL(const TSqlSrvFileData& aFileData)

	{

	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();

	CleanupStack::PushL(self);

	aFileData.IsSecureFileNameFmt() ? self->ConstructOpenSecureL(aFileData) : self->ConstructOpenL(aFileData);

	CleanupStack::Pop(self);

	return self;

	}

/**

Cleans up the allocated for the database connection memory and other resources.

*/

CSqlSrvDatabase::~CSqlSrvDatabase()

	{

    SQLPROFILER_DB_CLOSE((TUint)iDbHandle);

	TSqlCompactDbMapIterator compactDbIt(iCompactDbMap);

	TSqlCompactDbPair compactDbPair;

	while(compactDbIt.Next(compactDbPair))

		{

        __SQLASSERT(compactDbPair.iData, 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 "remove" operation actually decrements the security policy reference counter and destroys the policy

	//when the counter reaches 0. The counter value may be greater than 1 if the database is shared between

	//more than one connection)

	if(iSecureDbName)

		{

		::SqlServer().SecurityMap().Remove(iSecureDbName);

		//The security policy map owns iSecureDbName and iSecurityPolicy and is responsible for 

		//iSecureDbName and iSecurityPolicy destruction.

		}

    //The next step of the "resource release" process is to walk over iAttachDbMap entries, get the data part of

    //the found TSqlAttachDbPair objects, which is secure database name used as a key in iSecurityMap, and remove

    //the related entry from iSecurityMap. If the database is closed in normal circumstances, the iAttachDbMap

    //has no entries. But if the database client forgets to detach the used attached databases or if the Detach() call

    //fails (for example, with KErrNoMemory error), then at this point iAttachDbMap has one or more entries.

    //That means there are still some attached databases to this connection. This is not a problem, SQLite will take

    //care of them. The problem is that there are related entries in iSecurityMap map, owned by CSqlServer object,

    //and they won't be removed from the map till CSqlServer object is alive. This causes problems in OOM tests and in 

    //real life of the device.

    //For example, one database client opens "c:[11111111]a.db" and attaches "c:[11111111]b.db":

    // - c:[11111111]a.db database has been opened successfully. iSecurityMap has 1 entry:

    //            {"c:[11111111]a.db", <database security policy object>}.

    // - c:[11111111]b.db is attached to c:[11111111]a.db with name "db2". There will be 1 entry in iAttachDbMap:

    //            {"db2", "c:[11111111]a.db"} 

    //        and a new entry will be added to iSecurityMap:

    //            {"c:[11111111]b.db", <database security policy object>}. 2 entries in total in iSecurityMap.

    // - The database client attempts to detach the attached database but the opertaion fails during the execution

    //        of the DETACH sql statement. Both maps are intact.

    // - The database client attempts to close the database. The previous implementation of CSqlSrvDatabase::~CSqlSrvDatabase()

    //        would only remove "c:[11111111]a.db" entry from iSecurityMap and close the iAttachDbMap map.

    // The result: no opened or attached databases but there will be one entry in iSecurityMap: "c:[11111111]b.db".

    // OOM tests will report a memory leak in this case. On a real device, if "c:[11111111]b.db" gets deleted and

    // recreated again, unexpected memory leak will occur in CSqlSrvDatabase::ConstructCreateSecureL() because

    // 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);

        ::SqlServer().SecurityMap().Remove(attachDbPair.iData);

        }

	iAttachDbMap.Close();

	::CloseDbHandle(iDbHandle);

	}

/**

Initializes CSqlSrvDatabase data memebers with their default values.

@see MSqlPolicyInspector

@see RSqlSecurityMap

@see CSqlServer

*/

CSqlSrvDatabase::CSqlSrvDatabase() :

	iAttachDbMap(TSqlAttachDbLinearOrder(&Compare), TSqlAttachDbDestructor()),

	iCompactDbMap(TSqlCompactDbLinearOrder(&Compare2), TSqlCompactDbDestructor())

	{

	}

/**

Creates a new SQL database file and executes config pragmas.

This function is part of CSqlSrvDatabase instance initialization.

If the function leaves and the error is not KErrAlreadyExists, the database file will be deleted.

@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

     			 file session reference and some other database file related properties.

				 If this is a secure database, then the format of the name must be:

				 \<drive\>:\<[SID]database file name excluding the path\>.

				 If this is a non-secure database, then the file name has to be the full database file name.

				 "[SID]" refers to SID of the application which creates the database.

@see TSqlSrvFileData

@leave KErrNoMemory, an out of memory condition has occurred;

       KErrAlreadyExists, the file already exists.

                      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)

	{

	if(::FileExists(aFileData.Fs(), aFileData.FileName()))

		{

		__SQLLEAVE(KErrAlreadyExists);	

		}		

	TDbFileCleanup dbFileCleanup(aFileData, iDbHandle);

	CleanupStack::PushL(TCleanupItem(&DbFileCleanup, &dbFileCleanup));

	::CreateDbHandleL(aFileData, iDbHandle);

	SetConfigL(aFileData.ConfigParams(), ETrue);

	CleanupStack::Pop();//DbFileCleanup

	}

/**

Opens an existing SQL database file and executes config pragmas.

This function is part of CSqlSrvDatabase instance initialization.

@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

     			 file session reference and some other database file related properties.

				 If this is a secure database, then the format of the name must be:

				 \<drive\>:\<[SID]database file name excluding the path\>.

				 If this is a non-secure database, then the file name has to be the full database file name.

				 "[SID]" refers to SID of the application which creates the database.

				 If this is application's private database, then the format of aFileData is as it is described

				 in TSqlSrvFileData::SetFromHandleL() comments.

@leave KErrNoMemory, an out of memory condition has occurred;

       KErrNotFound, SQL database file not found.

                      Note that the function may also leave with some other database specific 

                      errors categorised as ESqlDbError, and other system-wide error codes.

@see TSqlSrvFileData

@see TSqlSrvFileData::SetFromHandleL()

*/

void CSqlSrvDatabase::OpenExistingDbFileL(const TSqlSrvFileData& aFileData)

	{

	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);	

			}

		}

	::CreateDbHandleL(aFileData, iDbHandle);

	//this is an existing database, only the cache size can be changed, the page size is persistent database property.

	//But for private databases, opened on the client side - the page size can be set (for the "create database" operations).

	SetConfigL(aFileData.ConfigParams(), aFileData.ContainHandles());

	}