--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/sql/SRC/Server/SqlSrvDatabase.inl Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,278 @@
+// Copyright (c) 2006-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:
+//
+
+/**
+
+ Retrieves a reference to the textual description of the error returned by the
+ most recent call to any of the functions:
+ - CSqlSrvDatabase::ExecL();
+ - CSqlSrvStatement::NewLC();
+ - CSqlSrvStatement::Next();
+ - CSqlSrvStatement::Reset();
+ - CSqlSrvStatement::Exec();
+
+ Note that the function can only return a reference to text for
+ database-specific type errors, i.e. those errors that are categorised as of
+ type ESqlDbError.
+
+ @return A non-modifiable pointer descriptor representing the most recent error
+ message. Note that message may be NULL, i.e. the descriptor may have
+ zero length.
+
+ @see CSqlSrvDatabase::ExecL()
+ @see CSqlSrvStatement::NewLC()
+ @see CSqlSrvStatement::Next()
+ @see CSqlSrvStatement::Reset()
+ @see CSqlSrvStatement::Exec()
+*/
+inline TPtrC CSqlSrvDatabase::LastErrorMessage() const
+ {
+ const void* errMsg = sqlite3_errmsg16(iDbHandle);//"errMsg" - zero terminated string
+ TPtrC msg(reinterpret_cast <const TUint16*> (errMsg));//terminating zero removed
+ return msg;
+ }
+
+/**
+Executes one or more 16-bit SQL statements.
+
+SQL statements of any kind can be executed, but note the following points:
+- the function does not return any records if the SQL statement type is "SELECT".
+- if an SQL statement contains one or more parameters, then the function will execute it,
+giving the parameters default NULL values.
+
+If the call to this function fails because of a database-specific type error
+(i.e. the error is categorised as of type ESqlDbError), then a textual description of
+the error can be obtained calling CSqlSrvDatabase::LastErrorMessage().
+
+@param aSqlStmt A zero-terminated string descriptor of 16-bit wide characters containing one or more
+ SQL statements. Each statement is separated by a ';' character.
+ Note that the ExecL() call can modify the content of aSqlStmt parameter.
+
+@leave KErrNoMemory, an out of memory condition has occured;
+ KSqlErrGeneral, a syntax error has occurred - text describing the problem
+ can be obtained by calling CSqlSrvDatabase::LastErrorMessage();
+ KErrPermissionDenied, the caller 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 CSqlSrvDatabase::LastErrorMessage()
+*/
+inline void CSqlSrvDatabase::ExecL(TDes16& aSqlStmt)
+ {
+ __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, aSqlStmt));
+ }
+
+/**
+Executes one or more 8-bit SQL statements.
+
+SQL statements of any kind can be executed, but note the following points:
+- the function does not return any records if the SQL statement type is "SELECT".
+- if an SQL statement contains one or more parameters, then the function will execute it,
+giving the parameters default NULL values.
+
+If the call to this function fails because of a database-specific type error
+(i.e. the error is categorised as of type ESqlDbError), then a textual description of
+the error can be obtained calling CSqlSrvDatabase::LastErrorMessage().
+
+@param aSqlStmt A zero-terminated string descriptor of 8-bit wide characters containing one or more
+ SQL statements. Each statement is separated by a ';' character.
+
+@leave KErrNoMemory, an out of memory condition has occured;
+ KSqlErrGeneral, a syntax error has occurred - text describing the problem
+ can be obtained by calling CSqlSrvDatabase::LastErrorMessage();
+ KErrPermissionDenied, the caller 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 CSqlSrvDatabase::LastErrorMessage()
+*/
+inline void CSqlSrvDatabase::ExecL(const TDesC8& aSqlStmt)
+ {
+ __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, aSqlStmt));
+ }
+
+/**
+Sets the transaction isolation level for the database.
+
+A transaction isolation level defines the way in which a transaction
+interacts with other transactions that may be in progress concurrently.
+
+Transaction isolation levels are defined by the values of the
+RSqlDatabase::TIsolationLevel enum.
+
+The default isolation level is RSqlDatabase::ESerializable
+
+Note that the isolation level is not a persistent property of the database.
+It is set to the default value, i.e. RSqlDatabase::ESerializable,
+whenever the database is created or opened.
+
+@param aLevel The isolation level to be set.
+
+@leave KErrNotSupported, invalid (not supported) transaction isolation level.
+ Current implementation of CSqlSrvDatabase::SetIsolationLevelL()
+ does not support RSqlDatabase::EReadCommitted and RSqlDatabase::ERepeatableRead
+ transaction isolation levels.
+*/
+inline void CSqlSrvDatabase::SetIsolationLevelL(RSqlDatabase::TIsolationLevel aLevel)
+ {
+ if(aLevel != RSqlDatabase::EReadUncommitted && aLevel != RSqlDatabase::ESerializable)
+ {
+ __SQLLEAVE(KErrNotSupported);
+ }
+ iAuthorizerDisabled = ETrue;
+ TInt err = ::DbExecStmt8(iDbHandle, aLevel == RSqlDatabase::EReadUncommitted ? KReadUncommittedPragma() : KSerializablePragma());
+ iAuthorizerDisabled = EFalse;
+ __SQLLEAVE_IF_ERROR(err);
+ }
+
+/**
+@return sqlite3 handle
+
+@panic SqlDb 7 In _DEBUG mode. iDbHandle is NULL.
+*/
+inline sqlite3* CSqlSrvDatabase::RawDbHandle() const
+ {
+ __SQLASSERT(iDbHandle != NULL, ESqlPanicInternalError);
+ return iDbHandle;
+ }
+
+/**
+@return A pointer to the database security policies object.
+
+Note that there may be no security policies in force for this database (if it is not a secure database).
+
+@see CSqlSecurityPolicy
+*/
+inline const CSqlSecurityPolicy* CSqlSrvDatabase::SecurityPolicy() const
+ {
+ return iSecurityPolicy;
+ }
+
+/**
+Installs user defined collations.
+
+At the moment 5 user defined collations with the following names are installed:
+- CompareC0 - 16-bit strings collated comaprison at level 0;
+- CompareC1 - 16-bit strings collated comaprison at level 1;
+- CompareC2 - 16-bit strings collated comaprison at level 2;
+- CompareC3 - 16-bit strings collated comaprison at level 3;
+- CompareF - 16-bit strings folded comaprison;
+
+These user defined collations can be used in the following cases:
+
+- as column constraint in "CREATE TABLE" SQL statements. For example:
+@code
+ CREATE TABLE A(Col1 TEXT COLLATE CompareC1)
+@endcode
+In this case every time when Col1 values have to be compared, the SQL server will use CompareC1 collation.
+
+- as column constraint in "CREATE INDEX" SQL statements. For example:
+@code
+ CREATE INDEX I ON A(Col1 COLLATE CompareC2)
+@endcode
+In this case SQL server will use CompareC2 collation to compare Col1 values when using the index.
+
+- In "ORDER BY" clause of "SELECT" SQL statements. For example:
+@code
+ SELECT * FROM A ORDER BY Col1 COLLATE CompareC3
+@endcode
+In this case SQL server will use CompareC3 collation to compare Col1 values when building the result set.
+
+This function is part of CSqlSrvDatabase instance initialization.
+
+@leave The function may leave with some database specific errors categorised as ESqlDbError.
+
+@see TSqlCollate
+@see TSqlCollate::InstallCollationsL()
+*/
+inline void CSqlSrvDatabase::InstallCollationsL()
+ {
+ TSqlCollationUtil collationUtil(iDbHandle);
+ collationUtil.InstallCollationsL();
+ }
+
+/**
+Stores the initial settings in the system settings table of a database.
+The initial settings are the specified collation dll name and version 0
+of the database configuration file.
+The collation dll name is used to uniquely identify the collation
+method which is used by the collation comparison methods:
+TDesC16::CompareC(), TDesC16::MatchC(), TDesC16::FindC().
+This function is used when a new database is created.
+
+@param aCollationDllName Collation dll name. It uniquely identifies the current collation method in use.
+ If the default collation method changes later then the database will be reindexed
+ and the new collation dll name will replace the existing one in the settings table.
+@param aDbConfigFileVersion Current config file version or KSqlNullDbConfigFileVersion
+@param aCompactionMode Database compaction mode, one of TSqlCompactionMode enum item values (except ESqlCompactionNotSet)
+
+@see TSqlCompactionMode
+
+@panic SqlDb 4 In _DEBUG mode if aCompactionMode parameter value is invalid.
+*/
+inline void CSqlSrvDatabase::StoreSettingsL(const TDesC& aCollationDllName, TInt aDbConfigFileVersion, TSqlCompactionMode aCompactionMode)
+ {
+ __SQLASSERT(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, ESqlPanicBadArgument);
+#if !defined(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)
+ TSqlDbSysSettings dbSettings(iDbHandle);
+ dbSettings.StoreSettingsL(KMainDb16, aCollationDllName, aDbConfigFileVersion, aCompactionMode);
+#else
+ aCollationDllName.Ptr(); // to avoid compile-time warning
+#endif // !(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)
+ }
+
+/**
+This function returns the number of database rows that were updated/inserted/deleted
+by the most recently completed INSERT, UPDATE, or DELETE statement.
+*/
+inline TInt CSqlSrvDatabase::LastChangesCount()
+ {
+ return sqlite3_changes(iDbHandle);
+ }
+
+/**
+@return Returns the ROWID of the most recent successful INSERT into the database from this database connection.
+ If no successful inserts have ever occurred on this database connection, zero is returned.
+*/
+inline TInt64 CSqlSrvDatabase::LastInsertedRowId()
+ {
+ return sqlite3_last_insert_rowid(iDbHandle);
+ }
+
+//Check that the caller has at least one of {Read, Write, Schema} policies and leave with
+//KErrPermissionDenied if it is not true.
+//The "schema" policy check should be evaluated last in order to prevent too many platsec warnings reported in the log files.
+//(It is very likely that the caller has either "read", "write" or both database security policies)
+inline void CSqlSrvDatabase::BasicSecurityPolicyCheckL(const CSqlSecurityPolicy& aSecurityPolicy)
+ {
+ MSqlPolicyInspector& inspector = ::SqlServer().SecurityInspector();
+ if(!(inspector.Check(aSecurityPolicy.DbPolicy(RSqlSecurityPolicy::EReadPolicy)) ||
+ inspector.Check(aSecurityPolicy.DbPolicy(RSqlSecurityPolicy::EWritePolicy))||
+ inspector.Check(aSecurityPolicy.DbPolicy(RSqlSecurityPolicy::ESchemaPolicy))))
+ {
+ __SQLLEAVE(KErrPermissionDenied);
+ }
+ }
+
+/**
+Current database connection transaction state.
+
+@return True, the current database connection is in transaction, false otherwise.
+*/
+inline TBool CSqlSrvDatabase::InTransaction() const
+ {
+ return !sqlite3_get_autocommit(iDbHandle);
+ }
+