--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/udbms/UD_INCR.CPP Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,429 @@
+// Copyright (c) 1998-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:
+// Client incremental class
+//
+//
+
+#include "UD_STD.H"
+
+// Class RDbIncremental
+
+/** Releases the resources used by the incremental operations object. If the operation
+is not yet complete, then the operation is abandoned and the database is rolled
+back to its state before the operation started. */
+EXPORT_C void RDbIncremental::Close()
+ {
+ iState.Close();
+ }
+
+/** Performs the next step in the incremental operation, returning when the step
+is complete.
+
+@param aStep Initially, contains the value returned from any of the initiating
+functions or the last call to perform an operational step. On return, contains
+a value which is less than or equal to the initial value. If it equals 0,
+then the operation has completed successfully and the incremental object should
+be closed.
+@return KErrNone if successful, or one of the DBMS database error codes. If
+this indicates an error, then the incremental object should be closed and
+the operation aborted. */
+EXPORT_C TInt RDbIncremental::Next(TInt& aStep)
+ {
+ __ASSERT_ALWAYS(aStep>0,Panic(EDbInvalidIncrementalStep));
+ TRAPD(r,iState->NextL(aStep));
+ return r;
+ }
+
+/** Performs the next step in the incremental operation, returning immediately
+and signalling the request status when the step is complete.
+
+This function is most effectively used when the incremental operation is packaged
+as an active object.
+
+Note that the step parameter is packaged to enable this API to work for asynchronous
+calls in client/server implementations of DBMS.
+
+@param aStep Initially, contains the value returned from any of the initiating
+functions or the last call to perform an operational step. On return, contains
+a value which is less than or equal to the initial value. If it equals 0,
+then the operation has completed successfully and the incremental object should
+be closed.
+@param aStatus The request status used to contain completion information for
+the function. On completion, contains the completion status or one of the
+DBMS database error codes. If this indicates an error, then the incremental
+object should be closed and the operation aborted.
+@see TPckgBuf */
+EXPORT_C void RDbIncremental::Next(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus)
+ {
+ __ASSERT_ALWAYS(aStep.operator()()>0,Panic(EDbInvalidIncrementalStep));
+ iState->Next(aStep,aStatus);
+ }
+
+LOCAL_C TInt Utility(RDbHandle<CDbIncremental>& aInc
+ ,RDbHandle<CDbDatabase>& aDb,TInt& aStep
+ ,CDbDatabase::TUtility aType)
+ {
+ TRAPD(r,aInc=aDb->UtilityL(aType,aStep));
+ return r;
+ }
+
+/** Initiates a database recovery operation.
+
+This is the incremental version of RDbDatabase::Recover().
+Recover() will try to rebuild database indexes if they are broken.
+If the database data is corrupted, it cannot be recovered.
+
+@param aDatabase The database to recover.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to NextL().
+
+@return KErrNone if successful, or one of the DBMS database error codes. If
+recovery fails with either KErrNoMemory or KErrDiskFull, then recovery may
+be attempted again when more memory or disk space is available.
+
+@see RDbDatabase::Recover()
+
+@capability Note For a secure shared database, the caller must satisfy the schema
+ access policy for the database.
+*/
+EXPORT_C TInt RDbIncremental::Recover(RDbDatabase& aDatabase,TInt& aStep)
+ {
+ return Utility(iState,aDatabase.iDatabase,aStep,CDbDatabase::ERecover);
+ }
+
+/** Initiates the operation of calculating and updating database statistics.
+
+This is the incremental form of RDbDatabase::UpdateStats()
+
+@param aDatabase The database whose statistics are to be updated.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to Next() to
+continue the operation.
+@return KErrNone if successful, otherwise another of the system-wide error
+codes.
+@see RDbDatabase::UpdateStats()
+
+@capability Note For a secure shared database, the caller must satisfy the schema
+ access policy for the database.
+*/
+EXPORT_C TInt RDbIncremental::UpdateStats(RDbDatabase& aDatabase,TInt& aStep)
+ {
+ return Utility(iState,aDatabase.iDatabase,aStep,CDbDatabase::EStats);
+ }
+
+/** Initiates the operation of compacting a database. This is the incremental form
+of RDbDatabase::Compact().
+
+@param aDatabase The database to compact.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to Next() to
+continue the operation.
+@return KErrNone if successful, otherwise another of the system-wide error
+codes.
+@see RDbDatabase::Compact()
+
+@capability Note For a secure shared database, the caller must satisfy the schema
+ access policy for the database.
+*/
+EXPORT_C TInt RDbIncremental::Compact(RDbDatabase& aDatabase,TInt& aStep)
+ {
+ return Utility(iState,aDatabase.iDatabase,aStep,CDbDatabase::ECompact);
+ }
+
+/** Initiates a table discard operation on a database. All indexes belonging to
+the table are also discarded as part of this operation.
+
+This is the incremental version of RDbDatabase::DropTable().
+
+@param aDatabase The database from which to drop the table.
+@param aTable The name of the table to drop.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to NextL().
+@return KErrNone if successful, or one of the DBMS database error codes. The
+Store database always returns KErrNotSupported for this function.
+@see RDbDatabase::DropTable()
+
+@capability Note For a secure shared database, the caller must satisfy the schema
+ access policy for the database.
+*/
+EXPORT_C TInt RDbIncremental::DropTable(RDbDatabase& aDatabase,const TDesC& aTable,TInt& aStep)
+ {
+ TRAPD(r,iState=aDatabase.iDatabase->DropTableL(aTable,aStep));
+ return r;
+ }
+
+/** Initiates a table alteration operation on a database. This is the incremental
+form of RDbDatabase::AlterTable().
+
+@param aDatabase The database which has the table to be altered.
+@param aTable The name of the table which is to be altered.
+@param aNewDef A column set describing the new definition for the table.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to NextL().
+@return KErrNone if successful, or one of the DBMS database error codes. Specifically,
+the function returns: KErrNotFound, if the table does not exist in the database.
+KErrBadName if a column name is invalid. KErrArgument if the new column set
+is empty, or there are duplicate column names, or if a column's maximum length
+is non-positive but not KDbUndefinedLength, or a non-numeric column has the
+auto-increment attribute, or an indexed column has been dropped, or a column
+has changed its type or attributes, or a not-null or auto-increment column
+has been added to a table which is not empty. KErrNotSupported if a column
+type is out of the recognised range, or an unknown attribute bit is set, or
+the maximum length for a Text8, Text16 or Binary column is more than 255.
+KErrTooBig if the resulting record size can be larger than 8200 bytes.
+@see RDbDatabase::AlterTable()
+
+@capability Note For a secure shared database, the caller must satisfy the schema
+ access policy for the database.
+*/
+EXPORT_C TInt RDbIncremental::AlterTable(RDbDatabase& aDatabase,const TDesC& aTable,const CDbColSet& aNewDef,TInt& aStep)
+ {
+ TRAPD(r,iState=aDatabase.iDatabase->AlterTableL(aTable,aNewDef,aStep));
+ return r;
+ }
+
+/** Initiates an index creation operation on a database. This is the incremental
+form of RDbDatabase::CreateIndex().
+
+@param aDatabase The database on which to create the index.
+@param aName A name for the created index.
+@param aTable The name of the table on which to create the index.
+@param aKey The key for the new index.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to NextL().
+@return KErrNone if successful, or one of the DBMS database error codes. Specifically,
+the function returns: KErrNotFound if the table does not exist in the database
+or a key column is not found in the table. KErrAlreadyExists if an index of
+the same name already exists on table or a duplicate key is present when building
+an index. Note that it is not possible to tell the difference between the
+possible causes of this error if index creation is not carried out incrementally.
+KErrBadName if an index or column name is invalid. KErrArgument if the key
+has no key columns or a fixed width column has a truncation length specified,
+or an invalid truncation length has been specified for a key column, or a
+LongText8 or LongText16 key column has no truncation length specified, or
+the key contains a Binary or LongBinary column. KErrNotSupported if a truncated
+key column is not the last one. KErrTooBig if the resulting key size is too
+big.
+@see RDbDatabase::CreateIndex()
+
+@capability Note For a secure shared database, the caller must satisfy the schema
+ access policy for the database.
+*/
+EXPORT_C TInt RDbIncremental::CreateIndex(RDbDatabase& aDatabase,const TDesC& aName,const TDesC& aTable,const CDbKey& aKey,TInt& aStep)
+ {
+ TRAPD(r,iState=aDatabase.iDatabase->CreateIndexL(aName,aTable,aKey,aStep));
+ return r;
+ }
+
+/** Initiates an index discard operation on the database. This is the incremental
+form of RDbDatabase::DropIndex().
+
+@param aDatabase The database from which to drop the index.
+@param aName The name of the index to drop.
+@param aTable The name of the table which has the index.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to NextL().
+@return KErrNone if successful, or one of the DBMS database error codes. Specifically,
+the function returns KErrNotFound if the table or index does not exist
+@see RDbDatabase::DropIndex()
+
+@capability Note For a secure shared database, the caller must satisfy the schema
+ access policy for the database.
+*/
+EXPORT_C TInt RDbIncremental::DropIndex(RDbDatabase& aDatabase,const TDesC& aName,const TDesC& aTable,TInt& aStep)
+ {
+ TRAPD(r,iState=aDatabase.iDatabase->DropIndexL(aName,aTable,aStep));
+ return r;
+ }
+
+//
+// Incremental SQL Data definition execution
+//
+LOCAL_C CDbIncremental* ExecuteDDLL(CDbDatabase& aDatabase,const TDesC& aSql,TDbTextComparison aComparison,TInt& aStep)
+ {
+ CDbIncremental* inc=aDatabase.ExecuteL(aSql,aComparison,aStep);
+ if ((inc==NULL)!=(aStep==0))
+ {
+ CDbObject::Destroy(inc);
+ __LEAVE(KErrArgument);
+ }
+ return inc;
+ }
+
+/** Initiates the execution of a DDL (SQL schema update) statement on the database,
+specifing additional comparison operations for some SQL statements.
+
+This is the incremental form of RDbDatabase::Execute().
+
+Note that to begin executing a DML (SQL data update) statement incrementally,
+use the RDbUpdate class.
+
+@param aDatabase The database on which the DDL (SQL schema update) statement
+is to execute.
+@param aSql The DDL SQL statement to be executed on the database.
+@param aComparison This argument is used in the execution of some SQL statements,
+and is ignored in all other SQL statements. Specifically: in CREATE INDEX
+statements, it specifies the comparison operation used for text columns in
+the index key. In UPDATE and DELETE statements, it specifies the comparison
+operation used to evaluate the WHERE clause.
+@param aStep On return, contains the initial step count for the incremental
+operation. This value should be passed in to subsequent calls to Next() to
+continue the operation.
+@return KErrNone if successful, otherwise another of the system-wide error
+codes.
+@see RDbDatabase::Execute()
+@see RDbUpdate
+
+@capability Note For a secure shared database, the caller must satisfy:
+ - the schema access policy for the database, if the SQL statement is
+ CREATE/DROP/ALTER;
+ - the write access policy for the table in the SQL, if the SQL statement is
+ INSERT/UPDATE/DELETE;
+*/
+EXPORT_C TInt RDbIncremental::Execute(RDbDatabase& aDatabase,const TDesC& aSql,TDbTextComparison aComparison,TInt& aStep)
+ {
+ TRAPD(r,iState=ExecuteDDLL(*aDatabase.iDatabase,aSql,aComparison,aStep));
+ return r;
+ }
+
+// Class RDbUpdate
+
+//
+// Incremental SQL Data definition execution
+//
+LOCAL_C CDbIncremental* ExecuteDMLL(CDbDatabase& aDatabase,const TDesC& aSql,TDbTextComparison aComparison,TInt& aRows)
+ {
+ CDbIncremental* inc=aDatabase.ExecuteL(aSql,aComparison,aRows);
+ if ((inc==NULL)==(aRows==0))
+ {
+ CDbObject::Destroy(inc);
+ __LEAVE(KErrArgument);
+ }
+ return inc;
+ }
+
+/** Initiates the incremental execution of a DML (SQL data update) statement on
+the database. This is similar to RDbDatabase::Execute().
+
+Note that to begin executing a DDL (SQL schema update) statement incrementally,
+use the RDbIncremental class.
+
+@param aDatabase The database on which the DML (SQL data update) statement
+is to execute.
+@param aSql A reference to a descriptor containing the DML statement to be
+executed.
+@param aComparison This argument is only used in the execution of some SQL
+statements. By default the comparison is EDbCompareNormal. For more information
+see RDbDatabase::Execute().
+@return KErrNone, if the operation is complete or 1, if the operation requires
+further incremental execution or another of the system-wide error codes.
+@see RDbIncremental
+@see RDbDatabase::Execute()
+
+@capability Note For a secure shared database, the caller must satisfy:
+ - the schema access policy for the database, if the SQL statement is
+ CREATE/DROP/ALTER;
+ - the write access policy for the table in the SQL, if the SQL statement is
+ INSERT/UPDATE/DELETE;
+*/
+EXPORT_C TInt RDbUpdate::Execute(RDbDatabase& aDatabase,const TDesC& aSql,TDbTextComparison aComparison)
+ {
+ TRAPD(r,iUpdate=ExecuteDMLL(*aDatabase.iDatabase,aSql,aComparison,iRows()));
+ return r;
+ }
+
+/** Releases the resources used by this incremental operation object. If the operation
+is not yet complete, then the operation is abandoned and the database is rolled
+back to its state before the operation started. */
+EXPORT_C void RDbUpdate::Close()
+ {
+ iUpdate.Close();
+ }
+
+/** Performs the next step in the incremental execution of the DML (SQL data update)
+statement synchronously. The function returns when the step is complete.
+
+Note that if the incremental step fails, then the incremental object should
+be closed and the operation abandoned.
+
+@return KErrNone if execution of the DML statement is complete or 1 if another
+step in the execution of the DML statement is needed. or another of the system-wide
+error codes is returned if the incremental step fails. */
+EXPORT_C TInt RDbUpdate::Next()
+ {
+ TRAPD(r,r=iUpdate->NextL(iRows()));
+ return r;
+ }
+
+/** Performs the next step in the incremental execution of the DML (SQL data update)
+statement asynchronously.
+
+The function returns immediately and signals when the step is complete.
+
+This function is most effectively used when the incremental operation is packaged
+as an active object.
+
+Note that if the incremental step fails, then the incremental object should
+be closed, and the operation abandoned.
+
+@param aStatus The request status used to contain completion information for
+the operation. On completion, it contains:KErrNone, if execution of the DML
+statement is complete or 1, if another step in the execution of the DML statement
+is needed. or another of the system-wide error codes, if the incremental step
+fails. */
+EXPORT_C void RDbUpdate::Next(TRequestStatus& aStatus)
+ {
+ iUpdate->Next(iRows,aStatus);
+ }
+
+/** Returns the number of rows currently affected by the execution of the DML (SQL
+data update) statement on the database.
+
+Once execution of the DML statement is complete, the value returned is the
+final total number of rows affected.
+
+@return The current/final number of rows affected by the execution of the
+DML statement. */
+EXPORT_C TInt RDbUpdate::RowCount() const
+ {
+ return CONST_CAST(TPckgBuf<TInt>&,iRows)();
+ }
+
+// Class CDbSyncIncremental
+
+//
+// Implement the asynchronous step in terms of the synchronous form
+//
+EXPORT_C void CDbSyncIncremental::Next(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus)
+ {
+ TRequestStatus* pStatus=&aStatus;
+ TRAPD(r,r=NextL(aStep.operator()())); // MSVC issue!!! cannot use aStep() directly
+ User::RequestComplete(pStatus,r);
+ }
+
+// Class CDbAsyncIncremental
+
+//
+// Implement the synchronous step in terms of the asynchronous form
+//
+EXPORT_C TBool CDbAsyncIncremental::NextL(TInt& aStep)
+ {
+ TRequestStatus status;
+ TPckgBuf<TInt> step=aStep;
+ Next(step,status);
+ User::WaitForRequest(status);
+ aStep=step();
+ return __LEAVE_IF_ERROR(status.Int());
+ }
+