// Copyright (c) 2005-2009 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 "SqlPanic.h"			//ESqlPanicInvalidObj, ESqlPanicObjExists

#include "SqlDatabaseImpl.h"	//CSqlDatabaseImpl

/**

Gets the category of the return code value that is returned by

a call to the SQL API.

A call to the SQL API may complete with a non-zero return code indicating that some

unexpected behaviour has occurred. This can be categorised in a number of ways,

for example, as a Symbian OS error, or as a database error etc etc. 

This function takes the return code value and gets the category associated with

that value. The categories are defined by the enum values of

the TSqlRetCodeClass enum.

@param aSqlRetCode The return code value returned from a call to any (member)

                   function that forms part of the SQL interface.

@return The category associated with the specified return code value. This is

        one of the TSqlRetCodeClass enum values.

@see TSqlRetCodeClass

@capability None

@publishedAll

@released

*/

EXPORT_C TSqlRetCodeClass SqlRetCodeClass(TInt aSqlRetCode)

	{

	if(aSqlRetCode >= 0)

		{

		return ESqlInformation;	

		}

	else if(aSqlRetCode <= KSqlErrGeneral)

		{

		return ESqlDbError;	

		}

	return ESqlOsError;

	}

/**

Initialises the pointer to the implementation object to NULL.

@capability None

*/

EXPORT_C RSqlDatabase::RSqlDatabase() :

	iImpl(NULL)

	{

	}

/**

Creates a new shared non-secure or private secure database.

@param aDbFileName The full path name of the file that is to host the database.

@param aConfig the configuration string "PARAM=VALUE;....".

			   The following parameters can be set using the configuration string:

			   cache_size=value - where "value" is the cache size in pages.

			   					  "value" must be a positive integer number;

			   page_size=value - where "value" is the page size in bytes.

			   					 The "page_size" parameter can accept the following values:

			   					 512, 1024, 2048, 4096, 8192, 16384, 32768;

			   encoding=value - where "value" is the desired database encoding.

			   					 "value" could be either "UTF-8" or "UTF-16";

        	   compaction=value - where "value" is the desired compaction mode. 

                  				  "value" could be either "background", "synchronous" or "manual".

@return KErrNone, the operation has completed successfully; 

        KErrNoMemory, an out of memory condition has occurred;

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

        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, invalid configuration string, invalid parameter values

        			  in the configuration string.

                      Note that database specific errors categorised as ESqlDbError, and

                      other system-wide error codes may also be returned.

@capability None

*/

EXPORT_C TInt RSqlDatabase::Create(const TDesC& aDbFileName, const TDesC8* aConfig)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbFileName));

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(aConfig ? (void)UTF::Printf(UTF::TTraceContext(UTF::EInternals), 

			KStrParam, 2, aConfig) : void(0));

	TRAPD(err, iImpl = CSqlDatabaseImpl::NewL(ESqlSrvDbCreate, aDbFileName, NULL, aConfig));

	return err;

	}

/**

Creates a new shared secure database.

@param aDbFileName       The name of the file that is to host the database.

                         The format of the name is \<drive\>:\<[SID]database file name excluding the path\>.

                         "[SID]" refers to the application SID.

@param aSecurityPolicy The container for the security policies.

@param aConfig the configuration string "PARAM=VALUE;...."

			   The following parameters can be set using the configuration string:

			   cache_size=value - where "value" is the cache size in pages.

			   					  "value" must be a positive integer number;

			   page_size=value - where "value" is the page size in bytes.

			   					 The "page_size" parameter can accept the following values:

			   					 512, 1024, 2048, 4096, 8192, 16384, 32768;

			   encoding=value - where "value" is the desired database encoding.

			   					 "value" could be either "UTF-8" or "UTF-16";

         	   compaction=value - where "value" is the desired compaction mode. 

                  				 "value" could be either "background", "synchronous" or "manual".

@return KErrNone, the operation has completed successfully;

        KErrNoMemory, an out of memory condition has occurred;

        KErrArgument, the file name does not refer to a secure database;

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

        			  invalid configuration string, invalid parameter values

        			  in the configuration string;

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

        KErrAlreadyExists, the file already exists;

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

        KErrInUse, the file is already open;

        KErrPermissionDenied, the caller does not satisfy the relevant database security policies.

                      Note that database specific errors categorised as ESqlDbError, and

                      other system-wide error codes may also be returned.

@capability The calling application must satisfy the database policy of RSqlSecurityPolicy::ESchemaPolicy type;

@see RSqlSecurityPolicy

@see RSqlSecurityPolicy::TPolicyType

*/

EXPORT_C TInt RSqlDatabase::Create(const TDesC& aDbFileName,

						const RSqlSecurityPolicy& aSecurityPolicy, const TDesC8* aConfig)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbFileName));

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(aConfig ? (void)UTF::Printf(UTF::TTraceContext(UTF::EInternals), 

			KStrParam, 2, aConfig) : void(0));

	TRAPD(err, 	iImpl = CSqlDatabaseImpl::NewL(ESqlSrvDbCreateSecure, aDbFileName,

			&aSecurityPolicy.Impl(), aConfig));

	return err;

	}

/**

Opens an existing database, which can be:

@code

 - shared non-secure;

 - shared secure;

 - private secure;

@endcode

@param aDbFileName The name of the file that hosts the database. 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 aDbFileName has to be the full database file name.

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

@param aConfig the configuration string "PARAM=VALUE;...."

			   The following parameters can be set using the configuration string:

			   cache_size=value - where "value" is the cache size in pages.

			   					  "value" must be a positive integer number;

@return KErrNone, the operation has completed successfully;

        KErrNoMemory, an out of memory condition has occurred;

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

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

        KErrInUse, the file is already open;

        KErrNotFound, database file not found;

        KErrArgument, invalid configuration string, invalid parameter values

        			  in the configuration string;

        KErrGeneral, missing or invalid security policies (if the database to be opened is a secure database);

        KErrPermissionDenied, the caller does not satisfy the relevant database security policies;

        KErrNotSupported, incompatible SQL security version (if the database to be opened is a secure database).

                      Note that database specific errors categorised as ESqlDbError, and

                      other system-wide error codes may also be returned.

@capability None, if aDbFileName refers to a non-secure database;

            RSqlSecurityPolicy::ESchemaPolicy or 

            RSqlSecurityPolicy::EReadPolicy or 

            RSqlSecurityPolicy::EWritePolicy database policy type, if aDbFileName refers to a secure database;

@see RSqlSecurityPolicy

@see RSqlSecurityPolicy::TPolicyType

*/

EXPORT_C TInt RSqlDatabase::Open(const TDesC& aDbFileName, const TDesC8* aConfig)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbFileName));

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(aConfig ? (void)UTF::Printf(UTF::TTraceContext(UTF::EInternals), 

			KStrParam, 2, aConfig) : void(0));

	TRAPD(err, iImpl = CSqlDatabaseImpl::NewL(ESqlSrvDbOpen, aDbFileName, NULL, aConfig));

	return err;

	}

/**

Creates a new shared non-secure or private secure database.

@param aDbFileName The full path name of the file that is to host the database.

@param aConfig the configuration string "PARAM=VALUE;...."

			   The following parameters can be set using the configuration string:

			   cache_size=value - where "value" is the cache size in pages.

			   					  "value" must be a positive integer number;

			   page_size=value - where "value" is the page size in bytes.

			   					 The "page_size" parameter can accept the following values:

			   					 512, 1024, 2048, 4096, 8192, 16384, 32768;

			   encoding=value - where "value" is the desired database encoding.

			   					 "value" could be either "UTF-8" or "UTF-16";

        	   compaction=value - where "value" is the desired compaction mode. 

                  				 "value" could be either "background", "synchronous" or "manual".

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

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

        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,

        			  invalid configuration string, invalid parameter values

        			  in the configuration string.

                      Note that the function may leave with database specific errors categorised as ESqlDbError and

                      other system-wide error codes.

@capability None

*/

EXPORT_C void RSqlDatabase::CreateL(const TDesC& aDbFileName, const TDesC8* aConfig)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbFileName));

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(aConfig ? (void)UTF::Printf(UTF::TTraceContext(UTF::EInternals), 

			KStrParam, 2, aConfig) : void(0));

	iImpl = CSqlDatabaseImpl::NewL(ESqlSrvDbCreate, aDbFileName, NULL, aConfig);

	}

/**

Creates a new shared secure database.

@param aDbFileName       The name of the file that is to host the database.

                         The format of the name is \<drive\>:\<[SID]database file name excluding the path\>.

                         "[SID]" refers to the application SID.

@param aSecurityPolicy   The container for the security policies.

@param aConfig the configuration string "PARAM=VALUE;...."

			   The following parameters can be set using the configuration string:

			   cache_size=value - where "value" is the cache size in pages.

			   					  "value" must be a positive integer number;

			   page_size=value - where "value" is the page size in bytes.

			   					 The "page_size" parameter can accept the following values:

			   					 512, 1024, 2048, 4096, 8192, 16384, 32768;

			   encoding=value - where "value" is the desired database encoding.

			   					 "value" could be either "UTF-8" or "UTF-16";

			   compaction=value - where "value" is the desired compaction mode. 

                  				  "value" could be either "background", "synchronous" or "manual".

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

        KErrArgument, the file name does not refer to a secure database;

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

        			  invalid configuration string, invalid parameter values

        			  in the configuration string;

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

        KErrAlreadyExists, the file already exists;

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

        KErrInUse, the file is already open;

        KErrPermissionDenied, the caller does not satisfy the relevant database security policies.

                      Note that the function may leave with database specific errors categorised as ESqlDbError and

                      other system-wide error codes.

@capability The calling application must satisfy the database policy of RSqlSecurityPolicy::ESchemaPolicy type;

@see RSqlSecurityPolicy

@see RSqlSecurityPolicy::TPolicyType

*/

EXPORT_C void RSqlDatabase::CreateL(const TDesC& aDbFileName,

				const RSqlSecurityPolicy& aSecurityPolicy, const TDesC8* aConfig)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbFileName));

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(aConfig ? (void)UTF::Printf(UTF::TTraceContext(UTF::EInternals), 

			KStrParam, 2, aConfig) : void(0));

	iImpl = CSqlDatabaseImpl::NewL(ESqlSrvDbCreateSecure, aDbFileName,

						&aSecurityPolicy.Impl(), aConfig);

	}

/**

Opens an existing database, which can be:

@code

 - shared non-secure;

 - shared secure;

 - private secure;

@endcode

@param aDbFileName The name of the file that hosts the database. 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 aDbFileName has to be the full database file name.

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

@param aConfig the configuration string "PARAM=VALUE;...."

			   The following parameters can be set using the configuration string:

			   cache_size=value - where "value" is the cache size in pages.

			   					  "value" must be a positive integer number;

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

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

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

        KErrInUse, the file is already open;

        KErrNotFound, database file not found;

        KErrArgument, invalid configuration string, invalid parameter values

        			  in the configuration string;

        KErrGeneral, missing or invalid security policies (if the database to be opened is a secure database);

        KErrPermissionDenied, the caller does not satisfy the relevant database security policies;

        KErrNotSupported, incompatible SQL security version (if the database to be opened is a secure database).

                      Note that the function may leave with database specific errors categorised as ESqlDbError and

                      other system-wide error codes.

@capability None, if aDbFileName refers to a non-secure database;

            RSqlSecurityPolicy::ESchemaPolicy or 

            RSqlSecurityPolicy::EReadPolicy or 

            RSqlSecurityPolicy::EWritePolicy database policy type, if aDbFileName refers to a secure database;

@see RSqlSecurityPolicy

@see RSqlSecurityPolicy::TPolicyType

*/

EXPORT_C void RSqlDatabase::OpenL(const TDesC& aDbFileName, const TDesC8* aConfig)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbFileName));

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(aConfig ? (void)UTF::Printf(UTF::TTraceContext(UTF::EInternals), 

			KStrParam, 2, aConfig) : void(0));

	iImpl = CSqlDatabaseImpl::NewL(ESqlSrvDbOpen, aDbFileName, NULL, aConfig);

	}

/**

Closes this handle to the database.

The function frees memory and any allocated resources.

You can reuse this object, but you must reinitialise it by calling

RSqlDatabase::Create() or RSqlDatabase::Open().

@see RSqlDatabase::Create()

@see RSqlDatabase::Open()

@capability None

*/

EXPORT_C void RSqlDatabase::Close()

	{

	SQLUTRACE_PROFILER(this);

	delete iImpl;

	iImpl = NULL;

	}

/**

Attaches an existing database to the current database connection.

The attached database can be read, written or modified. 

One database can be attched multiple times to the same connection, using different logical database names.

Tables in an attached database can be referred to using "database-name.table-name" syntax.

If an attached table doesn't have a duplicate table name in the main database, it doesn't 

require a database name prefix. 

Transactions involving multiple attached databases are atomic.

@param aDbFileName The name of the file that hosts the database. 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 private or shared non-secure database, then aDbFileName has to be the full 

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

@param aDbName Logical database name. It must be unique (per database connection). This is the name which can

               be used for accessing tables in the attached database. The syntax is "database-name.table-name".

@return KErrNone, the operation has completed successfully;

        KErrNoMemory, an out of memory condition has occurred;

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

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

        KErrInUse, the file is already open;

        KErrNotFound, database file not found;

        KErrGeneral, missing or invalid security policies (if the database to be opened is a secure database);

        KErrPermissionDenied, the caller does not satisfy the relevant database security policies;

        KErrNotSupported, incompatible SQL security version (if the database to be opened is a secure database).

                      Note that database specific errors categorised as ESqlDbError, and

                      other system-wide error codes may also be returned.

@capability None, if aDbFileName refers to a non-secure database;

            RSqlSecurityPolicy::ESchemaPolicy or 

            RSqlSecurityPolicy::EReadPolicy or 

            RSqlSecurityPolicy::EWritePolicy database policy type, if aDbFileName refers to a secure database;

@see RSqlSecurityPolicy

@see RSqlSecurityPolicy::TPolicyType

*/

EXPORT_C TInt RSqlDatabase::Attach(const TDesC& aDbFileName, const TDesC& aDbName)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrStrParam16, &aDbFileName, &aDbName));

	return Impl().Attach(aDbFileName, aDbName);

	}

/**

Detaches previously attached database.

@param aDbName Logical database name. 

			   The logical name of the database to be detached.

@return KErrNone, the operation completed has successfully;

        KErrNotFound, no attached database with aDbName name;

                      Note that database specific errors categorised as ESqlDbError, and

                      other system-wide error codes may also be returned.

@capability None

*/

EXPORT_C TInt RSqlDatabase::Detach(const TDesC& aDbName)

	{

	SQLUTRACE_PROFILER(this);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbName));

	return Impl().Detach(aDbName);

	}

/**

Copies a database file to the specified location.

Note that this is a static function, and its use is not

restricted to any specific RSqlDatabase instance.

@param aSrcDbFileName Source database file name.

					  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 aDbFileName has to be the full database file name.

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

@param aDestDbFileName Destination database file name.

					  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 aDbFileName has to be the full database file name.

					  "[SID]" refers to SID of the application which performs the copying operation.

The allowed copying operations are:

- secure to secure database. Only the application created the database is allowed to copy it.

- non-secure to non-secure database. No restrictions apply to this operation.

@return KErrNone, the operation completed has successfully;

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

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

        KErrInUse, the file is already open;

        KErrNotFound, database file not found;

        KErrPermissionDenied, the SID of the calling application does not match the SID of source or destination database.

                      Note that other system-wide error codes may also be returned.

@capability None

Note that if the source database is a secure database, only the application, which created the database, can copy it.

*/

EXPORT_C TInt RSqlDatabase::Copy(const TDesC& aSrcDbFileName, const TDesC& aDestDbFileName)

	{

	SQLUTRACE_PROFILER(0);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrStrParam16, 

			&aSrcDbFileName, &aDestDbFileName));

	return CSqlDatabaseImpl::Copy(aSrcDbFileName, aDestDbFileName);

	}

/**

Deletes the specified database file.

Note that this is a static function, and its use is not

restricted to any specific RSqlDatabase instance.

@param aDbFileName The name of the database file.

				   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 private or shared non-secure database, then aDbFileName has to be the 

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

@return KErrNone, the operation has completed successfully;

        KErrBadName, the file name is invalid - it has either a zero length or it is the name of a directory;

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

        KErrInUse, the database file is in use;

        KErrNotFound, the database file cannot be found;

        KErrAccessDenied, access to the database file is denied (e.g. it might be a read-only file);

        KErrPermissionDenied, the SID of the calling application does not match the SID of the database;

                      Note that other system-wide error codes may also be returned.

@capability None

Note that if the database to be deleted is a secure database, only the application, which created the database, can delete it.

*/

EXPORT_C TInt RSqlDatabase::Delete(const TDesC& aDbFileName)

	{

	SQLUTRACE_PROFILER(0);

	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KStrParam16, 1, &aDbFileName));

	return CSqlDatabaseImpl::Delete(aDbFileName);

	}

/**

Initializes aSecurityPolicy output parameter with a copy of the database security policies.

The caller is responsible for destroying the initialized aSecurityPolicy paramemter.

Note that there may be no security policies in force for this database.

@param aSecurityPolicy Input/Output parameter, which will be initialized with the database

						 security policies.

@return KErrNone, the operation has completed successfully;

		KErrNotSupported, the current database is not a secure database;

        KErrNoMemory, an out of memory condition has occurred;

@capability None

*/

EXPORT_C TInt RSqlDatabase::GetSecurityPolicy(RSqlSecurityPolicy& aSecurityPolicy) const