MCL/sf/app/speechsrv: comparison srsf/nssvasapi/nssvasdb/src/nssvascvasdb.cpp

equal deleted inserted replaced

-:cad71a31b7fc
+:e36f3802f733
+/*
+* Copyright (c) 2004-2006 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:  Implementation of VAS database handling
+*
+*/
+#include "nssvascvasdb.h"
+#include <e32test.h>
+#include <e32std.h>
+#include <e32svr.h>
+#include "rubydebug.h"
+#include "nssvascoreconstant.h"
+#include "nssvascrrd.h"
+#include "nssvasbackupobserver.h"
+// CONSTANTS
+// Name of the DB lock mutex
+_LIT( KLockMutex, "VASDATABASE" );
+#ifdef _DEBUG
+// used in UDEB macros only
+_LIT( KVasDbPanic, "VasCNssVasDb.cpp");
+#endif // _UDEB
+// Maximum size of tag array
+static const TInt KMaxTagArraySize = 50;
+const TInt KContextListGranularity = 5;
+const TInt KSqlStatementmaxLength = 120;
+// MACROS
+// Complementary macro for TRAPD
+#define REACT( err, codeblock ) if ( err != KErrNone ) { codeblock; }
+// ============================ Methods ===============================
+// -----------------------------------------------------------------------------
+// CNssVasDb::NewL
+// 2-level constructor
+// -----------------------------------------------------------------------------
+//
+CNssVasDb* CNssVasDb::NewL( CNssContextBuilder& contextBuilder,
+	                        CNssSpeechItemBuilder& speechItemBuilder )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::NewL" );
+CNssVasDb* self = new(ELeave) CNssVasDb( contextBuilder,
+speechItemBuilder );
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop( self );
+return self;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::~CNssVasDb
+// Standard C++ destructor
+// -----------------------------------------------------------------------------
+//
+CNssVasDb::~CNssVasDb()
+{
+RUBY_DEBUG0( "CNssVasDb::~CNssVasDb" );
+if ( iLocked )
+{
+RUBY_DEBUG0( "Signalling mutex in CNssVasDb::~CNssVasDb" );
+iMutex.Signal();
+}
+else
+{
+RUBY_DEBUG0( "NOT signalling mutex in CNssVasDb::~CNssVasDb iLocked = EFalse" );
+}
+if ( iClientHasOpenedDatabase )
+{
+CloseDatabase();
+}
+iMutex.Close();
+delete iBackupObserver;
+iCriticalSection.Close();
+RUBY_DEBUG0( "CNssVasDb::~CNssVasDb Mutex handle closed" );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::CNssVasDb
+// Standard C++ contructor
+// -----------------------------------------------------------------------------
+//
+CNssVasDb::CNssVasDb( CNssContextBuilder& aContextBuilder,
+	                  CNssSpeechItemBuilder& aSpeechItemBuilder )
+: iClientHasOpenedDatabase( EFalse ),
+iLocked( EFalse ),
+iContextBuilder( aContextBuilder ),
+iSpeechItemBuilder( aSpeechItemBuilder )
+{
+// empty
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::ConstructL
+// Symbian second constructor.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::ConstructL()
+{
+TInt err = iMutex.OpenGlobal( KLockMutex );
+if ( err != KErrNone )
+{
+RUBY_DEBUG0( "CNssVasDb::ConstructL Creating new global mutex" );
+iMutex.CreateGlobal( KLockMutex );
+}
+else
+{
+RUBY_DEBUG0( "CNssVasDb::ConstructL Using existing global mutex" );
+}
+iCriticalSection.CreateLocal();
+iBackupObserver = CNssVasBackupObserver::NewL( *this );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::RollbackCleanupFunction
+// This function is used to form iRollbackCleanupItem. When this item is
+// popped from the cleanup stack, it makes a rollback on VAS DB.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::RollbackCleanupFunction( TAny* aArg )
+{
+RUBY_DEBUG0( "CNssVasDb::RollbackCleanupFunction" );
+CNssVasDb* me = (CNssVasDb*)aArg;
+me->RollbackTransaction();
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::CreateDatabaseL
+// Creates a new database.
+// from a resource file.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::CreateDatabaseL()
+{
+User::LeaveIfError( iDbSession.Connect() );
+CleanupClosePushL( iDbSession );
+iDbcreator.CreateVasDatabaseL( iDbSession );
+CleanupStack::PopAndDestroy( &iDbSession );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::OpenDatabaseL
+// Opens the database. Reads the path and file name of the database
+// from a resource file.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::OpenDatabaseL()
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::OpenDatabaseL" );
+if ( !iClientHasOpenedDatabase )
+{
+RFs fs;
+User::LeaveIfError( fs.Connect() );
+CleanupClosePushL ( fs ); // Stack: file session
+// Open the database
+	    User::LeaveIfError( iDbSession.Connect() );
+User::LeaveIfError( iDatabase.Open( iDbSession,
+KVasDatabaseName, KVasDatabaseFormatString ) );
+User::LeaveIfError( fs.CharToDrive( KVasDatabaseDrive, iDrive ) );
+if ( iDatabase.IsDamaged() )
+{
+RUBY_DEBUG0( "CNssVasDb::OpenDatabaseL Recovering" );
+User::LeaveIfError( iDatabase.Recover() );
+}
+CleanupStack::PopAndDestroy( &fs );
+	    iClientHasOpenedDatabase = ETrue;
+}
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::CloseDatabase
+// Closes the database.
+// -----------------------------------------------------------------------------
+//
+TInt CNssVasDb::CloseDatabase()
+{
+RUBY_DEBUG0( "CNssVasDb::CloseDatabase" );
+iDatabase.Close();
+iDbSession.Close();
+iClientHasOpenedDatabase = EFalse;
+return KErrNone;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetModelBankIdLexiconIdL
+// Returns the model bank ID and the lexicon ID.
+// -----------------------------------------------------------------------------
+//
+TBool CNssVasDb::GetModelBankIdLexiconIdL( TUint32& aModelBankId, TUint32& aLexiconId )
+{
+TBool ret = EFalse;
+RDbView view;
+_LIT( KSQLGetModelBankLexicon, "select modelbankid,lexiconid from contexttable" );
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+CleanupClosePushL( view );
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery(
+KSQLGetModelBankLexicon, EDbCompareNormal ) ) );
+User::LeaveIfError( view.EvaluateAll() );
+// There is no ModelbankId or LexiconId
+if ( view.IsEmptyL() )
+{
+User::Leave( KErrNotFound );
+}
+// There is a ModelBankId and a LexiconId
+ret = ETrue;
+view.FirstL();
+view.GetL();
+// Get column set
+CDbColSet* columns = view.ColSetL();
+// Get column ordinals
+TDbColNo modelbankid_col = columns->ColNo( KModelBankIdCol );
+TDbColNo lexiconid_col = columns->ColNo( KLexiconIdCol );
+// Cleanup column set
+delete columns;
+aModelBankId = view.ColUint32( modelbankid_col );
+aLexiconId   = view.ColUint32( lexiconid_col );
+// Close view
+CleanupStack::PopAndDestroy( &view );
+// Release lock
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+return ret;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::TagExistsL
+// Checks if a context is empty.
+// -----------------------------------------------------------------------------
+//
+TBool CNssVasDb::TagExistL( TInt aContextId )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::TagExistL" );
+TBool   ret( EFalse );
+RDbView view;
+CleanupClosePushL(view);
+_LIT( KSQLGetTags, "select * from tagtable " );
+_LIT( KSQLWhereContextId, "where contextid=" );
+iSQLStatement = KSQLGetTags;
+iSQLStatement.Append( KSQLWhereContextId );
+iSQLStatement.AppendNumUC( aContextId );
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view.EvaluateAll() );
+if ( view.IsEmptyL() )
+{
+ret = EFalse;
+}
+else
+{
+ret = ETrue;
+}
+// Close view
+CleanupStack::PopAndDestroy( &view );
+return ret;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::TagCountL
+// Returns the number of tags.
+// -----------------------------------------------------------------------------
+//
+TInt CNssVasDb::TagCountL( TInt aContextId )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::TagCountL" );
+RDbView view;
+TInt    numberOfTags = 0;
+CleanupClosePushL( view );
+_LIT( KSQLGetTags, "select * from tagtable " );
+_LIT( KSQLWhereContextId, "where contextid=" );
+iSQLStatement = KSQLGetTags;
+iSQLStatement.Append( KSQLWhereContextId );
+iSQLStatement.AppendNumUC( aContextId );
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view.EvaluateAll() );
+numberOfTags = view.CountL();
+view.Close();
+CleanupStack::PopAndDestroy( &view );
+return numberOfTags;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::CommitIfSuccess
+// Commits or rolls back accoring to success parameter.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::CommitIfSuccess( RDbDatabase /*aDatabase*/, TInt aSuccess, TBool aCompactIfCommit )
+{
+if ( aSuccess >= 0 )
+{
+CommitTransaction( aCompactIfCommit );
+}
+else
+{
+// Otherwise, roll back the transaction and release the lock.
+RollbackTransaction();
+}
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::SaveContextL
+// Saves a newly created context. The Context ID is assigned and returned
+// using the reference parameter.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::SaveContextL( CNssContext& aContext, TInt& aContextId )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::SaveContextL" );
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+// Locks the database for the use of this process only
+TInt error = StartTransaction();
+if ( error != KErrNone )
+{
+RUBY_DEBUG0( "CNssVasDb error: could not lock database." );
+User::Leave( KErrGeneral );
+}
+TRAP( error, SaveContextL( &aContext, aContextId ) );
+REACT( error, RUBY_DEBUG0( "Context saving failed" ) );
+if ( error == KErrNone )
+{
+TRAP ( error, DoUpdateContextClientDataL( aContext ) );
+}
+CommitIfSuccess( iDatabase, error, ETrue );
+User::LeaveIfError( error );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateContextL
+// Updates the context to VAS DB.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateContextL( CNssContext& aContext )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextL" );
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+TInt error = StartTransaction();
+if ( error != KErrNone )
+{
+RUBY_DEBUG0( "CNssVasDb error: could not lock database." );
+User::Leave( KErrGeneral );
+}
+TRAP( error, DoUpdateContextL( aContext ) );
+REACT( error, RUBY_DEBUG0( "Context updating failed" ) );
+CommitIfSuccess( iDatabase, error, ETrue );
+User::LeaveIfError( error );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateContextInsideTransactionL
+// Updates the context to VAS DB.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateContextInsideTransactionL( CNssContext& aContext )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextInsideTransactionL" );
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+DoUpdateContextL( aContext );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateContextClientDataL
+// Updates the client data of the context.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateContextClientDataL( CNssContext& aContext )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextClientDataL" );
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+TInt error = StartTransaction();
+if ( error != KErrNone )
+{
+RUBY_DEBUG0( "CNssVasDb error: could not lock database." );
+User::Leave( KErrGeneral );
+}
+TRAP( error, DoUpdateContextClientDataL( aContext ) );
+CommitIfSuccess( iDatabase, error, ETrue );
+User::LeaveIfError( error );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetDefaultModelBankIdL
+// Usually, all contexts use the same Model Bank. This function
+// returns the first model bank ID it finds.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::GetDefaultModelBankIdL( TUint32& aId )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::GetDefaultModelBankIdL" );
+_LIT( KSQLGetAll,"select modelbankid from contexttable");
+iSQLStatement = KSQLGetAll;
+if ( !iClientHasOpenedDatabase )
+{
+User::Leave( KErrDbNotSet );
+}
+StartTransaction();
+CreatePushRollbackItemLC();
+RDbView view;
+CleanupClosePushL(view);
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view.EvaluateAll() );
+if ( view.IsEmptyL() )
+{
+	    User::Leave( KErrNotFound );
+}
+// Get column set
+CDbColSet* columns = view.ColSetL();
+// Get model bank id column ordinal
+	TDbColNo modelbankid_col= columns->ColNo( KModelBankIdCol );
+	delete columns;
+	view.FirstL();
+view.GetL(); // Retrieve the current row - actually reads the row from the database.
+aId = view.ColUint32( modelbankid_col );
+CleanupStack::PopAndDestroy( &view );// close view
+// Rollback cleanup
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::ResetModelBankL
+// Usually, all contexts use the same Model Bank. When the model bank is reseted,
+// (=speaker independent models are resotred and speaker adaptation is destroyed)
+// the model bank ID changes for all contexts.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::ResetModelBankL( TUint32 aNewId )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::ResetModelBankL" );
+_LIT( KSQLUpdateModelbank,"update contexttable set modelbankid=");
+iSQLStatement = KSQLUpdateModelbank;
+iSQLStatement.AppendNumUC( aNewId );
+if ( !iClientHasOpenedDatabase )
+{
+User::Leave( KErrDbNotSet );
+}
+StartTransaction();
+CreatePushRollbackItemLC();
+User::LeaveIfError( iDatabase.Execute( iSQLStatement ) );
+CleanupStack::Pop();  // Rollback cleanup item
+User::LeaveIfError( CommitTransaction( ETrue ) );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetContextByNameL
+// Reads a context from VAS DB by name.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssContext>* CNssVasDb::GetContextByNameL(const TDesC& aName)
+{
+	RUBY_DEBUG_BLOCK("CNssVasDb::GetContextByNameL");
+_LIT( KSQLGetAll,"select * from contexttable ");
+_LIT( KSQLWhereName,"where name='");
+_LIT( KTick,"' ");
+iSQLStatement = KSQLGetAll;
+iSQLStatement.Append( KSQLWhereName );
+iSQLStatement.Append( aName );
+iSQLStatement.Append( KTick );
+return GetContextL( iSQLStatement );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetGlobalContexts
+// Reads all global contexts from VAS DB.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssContext>* CNssVasDb::GetGlobalContexts()
+{
+	RUBY_DEBUG0("CNssVasDb::GetGlobalContexts");
+_LIT( KSQLGetAll,"select * from contexttable ");
+_LIT( KSQLWhereGlobal,"where global=1");
+iSQLStatement = KSQLGetAll;
+iSQLStatement.Append( KSQLWhereGlobal );
+CArrayPtrFlat<CNssContext>* ret( NULL );
+TRAPD( error, ret = GetContextL( iSQLStatement ) );
+if ( error != KErrNone )
+{
+return NULL;
+}
+return ret;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetAllContexts
+// Reads all contexts from VAS DB.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssContext>* CNssVasDb::GetAllContexts()
+{
+RUBY_DEBUG0("CNssVasDb::GetAllContexts");
+_LIT( KSQLGetAll,"select * from contexttable ");
+iSQLStatement = KSQLGetAll;
+CArrayPtrFlat<CNssContext>* ret( NULL );
+TRAPD( error, ret = GetContextL( iSQLStatement ) );
+if ( error != KErrNone )
+{
+return NULL;
+}
+return ret;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetContextL
+// Executes the SQL query. After the query has selected a list of contexts,
+// these contexts are read from DB to memory.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssContext>* CNssVasDb::GetContextL(const TDesC& aSQLStatement)
+{
+RUBY_DEBUG_BLOCK("CNssVasDb::GetContextL");
+__ASSERT_DEBUG( aSQLStatement.Left( 6 ).Compare( _L("select") ) == 0,
+User::Panic( KVasDbPanic, __LINE__ ) );
+if ( !iClientHasOpenedDatabase )
+{
+User::Leave( KErrDbNotSet );
+}
+TInt ret = StartTransaction();
+RUBY_DEBUG1("Started transaction. Error code [%d]", ret);
+CreatePushRollbackItemLC();
+CArrayPtrFlat<CNssContext>* contextList = GetContextInsideTransactionL( aSQLStatement );
+// Rollback cleanup (just to avoid automatic locking)
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+return contextList;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetContextInsideTransaction
+// Reads a context by name. Assumes that a transaction has already been started.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssContext>* CNssVasDb::GetContextInsideTransactionL( const TDesC& aSQLStatement )
+{
+RUBY_DEBUG_BLOCK("CNssVasDb::GetContextInsideTransactionL");
+RDbView view;
+CleanupClosePushL(view);
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( aSQLStatement, EDbCompareNormal ) ) );
+RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Prepared query");
+User::LeaveIfError( view.EvaluateAll() );
+RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Evaluated query");
+if ( view.IsEmptyL() )
+{
+RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Empty view. Leaving with KErrNotFound");
+	    User::Leave( KErrNotFound );
+}
+CArrayPtrFlat<CNssContext>* contextList =
+new (ELeave) CArrayPtrFlat<CNssContext>( KContextListGranularity );
+CleanupStack::PushL( contextList );
+CleanupResetAndDestroyPushL( *contextList );
+RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Before FillContextListArrayL");
+FillContextListArrayL(view, *contextList);
+CleanupStack::Pop( contextList ); // ResetAndDestroy
+CleanupStack::Pop( contextList );  // array itself
+CleanupStack::PopAndDestroy( &view );// close view
+return( contextList );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagReferenceList
+// Fetches tag references for all tags in a context.
+// -----------------------------------------------------------------------------
+//
+TNssTagReferenceListArray* CNssVasDb::GetTagReferenceListL( TInt aContextId )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::GetTagReferenceListL" );
+RDbView view;
+TNssTagReference tagRef;
+TNssTagReferenceListArray* tagArray =
+new (ELeave) TNssTagReferenceListArray( KMaxTagArraySize );
+CleanupStack::PushL( tagArray );
+if ( !iClientHasOpenedDatabase )
+{
+User::Leave( KErrDbNotSet );
+}
+// Start transaction - lock database
+StartTransaction();
+CreatePushRollbackItemLC();
+// Make a query, which lists all tags in the context.
+// Making a CNssTagReferece only requires tagid and name.
+_LIT( KSQLGetTag, "select tagid,name from tagtable where contextid=" );
+iSQLStatement = KSQLGetTag;
+iSQLStatement.AppendNumUC( aContextId );
+CleanupClosePushL(view);
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view.EvaluateAll() );
+if ( view.IsEmptyL() )
+{
+	    User::Leave( KErrNotFound );
+}
+// Get column set
+CDbColSet* columns = view.ColSetL();
+// Get column ordinals
+TDbColNo name_col  = columns->ColNo( KNameCol );
+TDbColNo tagid_col = columns->ColNo( KTagIdCol );
+delete columns;
+for( view.FirstL(); view.AtRow(); view.NextL() )
+{
+view.GetL();
+	    tagRef.iTagName = view.ColDes( name_col );
+	    tagRef.iTagId   = view.ColUint32( tagid_col );
+	    tagArray->AppendL( tagRef );
+}
+// Close view
+CleanupStack::PopAndDestroy( &view );
+// Finish transaction - release lock
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+// Return result
+CleanupStack::Pop( tagArray );
+return( tagArray );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::SaveTagL
+// Saves a newly created tag. When a tag is saved, a Tag ID is assigned to it.
+// This Tag ID is returned in the reference parameter.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::SaveTagL( CNssTag& aTag, TInt& aNewId )
+{
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+// Locks the database for the use of this process only
+TInt error = StartTransaction();
+if ( error != KErrNone )
+{
+RUBY_DEBUG0( "CNssVasDb error: could not lock database." );
+User::Leave( KErrGeneral );
+}
+TInt contextId; // Discard context ID
+CNssContext* context = static_cast<CNssContext*> ( aTag.Context() );
+TRAP( error, SaveContextL( context, contextId ) );
+if ( error == KErrItemAlreadyExist || error == KErrNone )
+{
+TRAP( error, SaveTagL( &aTag, aNewId ) );
+}
+else
+{
+RollbackTransaction();
+User::Leave( error );
+}
+// Check SavetagL result
+if ( error != KErrNone )
+{
+RollbackTransaction();
+User::Leave( error );
+}
+else
+{
+CNssRRD* rrd = static_cast<CNssRRD*>( aTag.RRD() );
+rrd->SetTagId( aNewId );
+TRAPD( error, SaveRRDL( rrd ) );
+	    REACT( error, RUBY_DEBUG0( "RRD saving failed." ) );
+CommitIfSuccess( iDatabase, error, ETrue );
+}
+User::LeaveIfError( error );
+}
+// ---------------------------------------------------------
+// CNssVasDb::SaveTagsL
+// Saves several tags in one commit.
+// ---------------------------------------------------------
+//
+void CNssVasDb::SaveTagsL( CArrayPtrFlat<CNssTag>* aTagArray, RArray<TInt>& aTagIdArray )
+{
+	CleanupClosePushL( aTagIdArray );
+TInt k( 0 );
+TInt error( KErrNone );
+if ( !iClientHasOpenedDatabase )
+{
+User::Leave( KErrDbNotSet );
+}
+// Locks the database for the use of this process only
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC(); // Stack: rollback cleanup
+RArray<TInt> contextIds;
+CleanupClosePushL( contextIds ); // Stack: rollback cleanup, contextIds
+for ( k = 0; k < aTagArray->Count(); k++ )
+{
+CNssTag* tag = (*aTagArray)[k];
+CNssContext* context = static_cast<CNssContext*> ( tag->Context() );
+if ( contextIds.Find( context->ContextId() ) == KErrNotFound )
+{
+TInt contextId;
+TRAP( error, SaveContextL( context, contextId ) );
+// We accept leaves with error KErrAlreadyExists
+if ( error != KErrNone && error != KErrAlreadyExists )
+{
+break;
+}
+contextIds.Append( context->ContextId() );
+}
+}
+// Close context id array
+CleanupStack::PopAndDestroy( &contextIds ); // Stack: Rollback cleanup
+// We accept leaves with error KErrAlreadyExists
+if ( error != KErrNone && error != KErrAlreadyExists )
+{
+User::Leave( error );
+}
+TInt id;
+for ( k = 0; k < aTagArray->Count(); k++ )
+{
+CNssTag* tag = (*aTagArray)[k];
+if ( tag->TagId() == KNssVASDbDefaultValue )
+{
+SaveTagL( tag, id );
+CNssRRD* rrd = static_cast<CNssRRD*>( tag->RRD() );
+rrd->SetTagId( id );
+	        SaveRRDL( rrd );
+User::LeaveIfError( aTagIdArray.Append( id ) );
+}
+else{
+UpdateTagInTransactionL( *tag );
+User::LeaveIfError( aTagIdArray.Append( tag->TagId() ) );
+}
+}
+User::LeaveIfError( CommitTransaction( ETrue ) );
+// Pop rollback cleanup
+// (which would have made database rollback, if a leave had happened)
+CleanupStack::Pop();  // Rollback cleanup item
+	CleanupStack::Pop();
+}
+// ---------------------------------------------------------
+// CNssVasDb::DeleteTagsL
+// Deletes several tags in one commit.
+// ---------------------------------------------------------
+//
+void CNssVasDb::DeleteTagsL( const RArray<TUint32>& aTagIdArray )
+{
+TInt k( 0 );
+if ( !iClientHasOpenedDatabase )
+{
+User::Leave( KErrDbNotSet );
+}
+// Locks the database for the use of this process only
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+for ( k = 0; k < aTagIdArray.Count(); k++ )
+{
+DeleteTagInsideTransactionL( aTagIdArray[k] );
+}
+User::LeaveIfError( CommitTransaction( ETrue ) );
+// Pop rollback cleanup
+// (which would have made database rollback, if a leave had happened)
+CleanupStack::Pop();  // Rollback cleanup item
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateTagL
+// Updates the data of an existing tag.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateTagL( CNssTag& aTag )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateTagL" );
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+// Locks the database for the use of this process only
+User::LeaveIfError( StartTransaction() );
+TRAPD( error, UpdateTagInTransactionL( aTag ) );
+CommitIfSuccess( iDatabase, error, ETrue );
+User::LeaveIfError( error );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateTagRuleIDs
+// Changes the Rule IDs of some tags. The Rule ID changes, when
+// and already trained tags is retrained.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateTagRuleIDsL( const RArray<TNssSpeechItem>& aRetrainedTags )
+{
+TInt error( KErrNone );
+if ( !iClientHasOpenedDatabase )
+{
+User::Leave( KErrDbNotSet );
+}
+_LIT( KSQLUpdateTag,"update tagtable set ");
+_LIT( KEqual,"=");
+_LIT( KSQLWhereTagIdIs," where tagid = ");
+TInt count = aRetrainedTags.Count();
+if ( count > 0 )
+{
+return;
+}
+// Start transaction
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+// Make the changes to Rule IDs
+for ( TInt k( 0 ); k < count; k++ )
+{
+// "update tagtable set "
+iSQLStatement = KSQLUpdateTag;
+// "ruleid=1234"
+iSQLStatement.Append( KRuleIdCol );
+iSQLStatement.Append( KEqual );
+iSQLStatement.AppendNumUC( aRetrainedTags[k].iRuleId );
+// " where tagid = 5678"
+iSQLStatement.Append( KSQLWhereTagIdIs );
+iSQLStatement.AppendNumUC( aRetrainedTags[k].iTagId );
+error =  iDatabase.Execute( iSQLStatement );
+if ( error < KErrNone )
+{
+ReleaseDiskSpace();
+User::Leave( error );
+}
+}
+// Commit transaction
+error = CommitTransaction( ETrue );
+if ( error )
+{
+ReleaseDiskSpace();
+User::Leave( error );
+}
+// Pop rollback cleanup object
+CleanupStack::Pop();  // Rollback cleanup item
+ReleaseDiskSpace();
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::SaveContextL
+// Saves a newly created context. When a context is saved, a Context ID is
+// assigned to it. This id is returned using the reference parameter.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::SaveContextL( CNssContext* aContext, TInt& aContextId )
+{
+TBuf<KNssVasDbContextName> name;
+RDbView view1;
+_LIT( KSQLAdd, "select * from contexttable " );
+_LIT( KSQLWhereName, "where name='" );
+_LIT( KTick, "' " );
+//Check to see if a context already exist with the new name
+iSQLStatement = KSQLAdd;
+iSQLStatement.Append( KSQLWhereName );
+iSQLStatement.Append( aContext->ContextName() );
+iSQLStatement.Append( KTick );
+CleanupClosePushL( view1 );
+User::LeaveIfError( view1.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view1.EvaluateAll() );
+if ( !view1.IsEmptyL() ) // context with that name already exist so return status
+{
+// Get column set
+CDbColSet* columns1 = view1.ColSetL();
+TDbColNo contextid_col = columns1->ColNo( KContextIdCol );
+	    delete columns1;
+view1.FirstL();
+view1.GetL();
+	    //Get the  unique contextid key just generated
+	    aContextId = view1.ColUint32(contextid_col);
+	    aContext->SetContextId( aContextId );
+	    view1.Close();
+	    CleanupStack::PopAndDestroy( &view1 );
+User::Leave( KErrAlreadyExists );
+}
+else{
+view1.Close();
+	    CleanupStack::PopAndDestroy( &view1 );
+	    RDbView view2;
+CleanupClosePushL( view2 );
+	    User::LeaveIfError( view2.Prepare( iDatabase, TDbQuery(KSQLAdd,EDbCompareNormal)));
+User::LeaveIfError( view2.EvaluateAll() );
+	    // Get column set
+CDbColSet* columns = view2.ColSetL();
+// Get column ordinals
+TDbColNo name_col = columns->ColNo( KNameCol );
+TDbColNo global_col = columns->ColNo( KGlobalCol );
+	    TDbColNo grammarid_col = columns->ColNo( KGrammarIdCol );
+	    TDbColNo lexiconid_col = columns->ColNo( KLexiconIdCol );
+	    TDbColNo modelbankid_col = columns->ColNo( KModelBankIdCol );
+	    TDbColNo contextid_col = columns->ColNo( KContextIdCol );
+	    delete columns;
+	    // Begin process of inserting a row...
+	    view2.InsertL();
+	    // set column values...
+	    view2.SetColL( name_col, aContext->ContextName() );
+	    view2.SetColL( global_col, aContext->IsGlobal() );
+	    view2.SetColL( lexiconid_col, aContext->LexiconId() );
+	    view2.SetColL( grammarid_col, aContext->GrammarId() );
+	    view2.SetColL( modelbankid_col, aContext->ModelBankId() );
+	    // add the row to the table...
+	    view2.PutL();
+	    view2.GetL();
+//Get the  unique contextid key just generated
+	    aContextId = view2.ColUint32( contextid_col );
+	    aContext->SetContextId( aContextId );
+	    name = view2.ColDes( name_col );
+	    view2.Close();
+	    CleanupStack::PopAndDestroy( &view2 );
+}
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::SaveTagL
+// Saves a newly created tag. When a tag is saved, a Tag ID is assigned to it.
+// This id is returned using the reference parameter.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::SaveTagL( CNssTag* aTag, TInt& aNewId )
+{
+	RDbView view;
+_LIT( KSQLGet,"select * from tagtable");
+	CleanupClosePushL(view);
+	User::LeaveIfError( view.Prepare( iDatabase, TDbQuery(KSQLGet,EDbCompareNormal)));
+	User::LeaveIfError( view.EvaluateAll());
+	// Get column set
+CDbColSet* columns = view.ColSetL();
+// Get column ordinals
+TDbColNo name_col           = columns->ColNo( KNameCol );
+	TDbColNo tagid_col          = columns->ColNo( KTagIdCol );
+	TDbColNo contextid_col      = columns->ColNo( KContextIdCol );
+	TDbColNo ruleid_col         = columns->ColNo( KRuleIdCol );
+	delete columns;
+	// Begin process of inserting a row...
+	view.InsertL();
+	// set column values...
+	CNssContext* context = static_cast<CNssContext*> ( aTag->Context() );
+	CNssSpeechItem* speechItem = static_cast<CNssSpeechItem*> ( aTag->SpeechItem() );
+	#ifdef __SIND_EXTENSIONS
+	    view.SetColL( name_col, aTag->SpeechItem()->RawText() );
+	#else
+	    view.SetColL( name_col, aTag->SpeechItem()->Text() );
+	#endif  // __SIND_EXTENSIONS
+	view.SetColL( contextid_col, context->ContextId() );
+	view.SetColL( ruleid_col, speechItem->RuleID() );
+	// add the row to the table...
+	view.PutL();
+aNewId = view.ColUint32( tagid_col );
+	// finished - so close the view
+	view.Close();
+	CleanupStack::PopAndDestroy( &view );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::SaveRRDL
+// Reads RRD from DB to memory. Utility function when reading tags.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::SaveRRDL( CNssRRD* aRRD )
+{
+TInt position;
+	RDbView view1,view2;
+	_LIT( KSQLAddRRDText, "select * from rrdtexttable");
+	_LIT( KSQLAddRRDId,   "select * from rrdinttable");
+// Save the integer array, if we have one.
+if ( aRRD->IntArray() )
+{
+	    CleanupClosePushL(view1);
+	    User::LeaveIfError( view1.Prepare( iDatabase, TDbQuery( KSQLAddRRDId, EDbCompareNormal ) ) );
+	    User::LeaveIfError( view1.EvaluateAll());
+	    // Get column set
+CDbColSet* columns1 = view1.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col           = columns1->ColNo( KTagIdCol );
+	    TDbColNo rrdint_col          = columns1->ColNo( KRRDIntCol );
+TDbColNo rrdposition_col1    = columns1->ColNo( KRRDPositionCol );
+	    delete columns1;
+	    // Begin process of inserting a row...
+	    // set column values for id table...
+for( position=0; position<aRRD->IntArray()->Count(); position++ )
+{
+	        view1.InsertL();
+	        view1.SetColL( tagid_col,aRRD->TagId() );
+	        view1.SetColL(rrdint_col,aRRD->IntArray()->At( position ) );
+	        view1.SetColL(rrdposition_col1,position);
+	        // add the row to the table...
+	        view1.PutL();
+	        }
+	    // finished - so close the view
+	    view1.Close();
+	    CleanupStack::PopAndDestroy( &view1 );
+}
+// Save the text array, if we have one
+if ( aRRD->TextArray() )
+{
+	    CleanupClosePushL( view2 );
+User::LeaveIfError( view2.Prepare( iDatabase,
+TDbQuery( KSQLAddRRDText, EDbCompareNormal ) ) );
+	    User::LeaveIfError( view2.EvaluateAll() );
+// Get column set
+CDbColSet* columns2 = view2.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col2       = columns2->ColNo( KTagIdCol );
+	    TDbColNo rrdtext_col2     = columns2->ColNo( KRRDTextCol );
+TDbColNo rrdposition_col2 = columns2->ColNo( KRRDPositionCol );
+	    delete columns2;
+	    //set colum values for text table
+	    for( position = 0; position < aRRD->TextArray()->Count(); position++ )
+{
+	        view2.InsertL();
+	        view2.SetColL( tagid_col2, aRRD->TagId() );
+	        view2.SetColL( rrdtext_col2, aRRD->TextArray()->At( position ) );
+	        view2.SetColL( rrdposition_col2, position );
+	        view2.PutL();
+}
+	    // add the row to the table...
+	    // finished - so close the view
+	    view2.Close();
+	    CleanupStack::PopAndDestroy( &view2 );
+}
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::FillRRDL
+// Reads RRD from DB to memory. Utility function when reading tags.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::FillRRDL( TUint32 aTagId, CNssRRD& aRRD )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::FillRRDL" );
+TInt position;
+	RDbView view1,view2;
+	_LIT( KSQLAddRRDText, "select * from rrdtexttable ");
+	_LIT( KSQLAddRRDId,   "select * from rrdinttable ");
+	_LIT( KSQLWhereTagId,"where tagid=");
+	iSQLStatement = KSQLAddRRDId;
+	iSQLStatement.Append( KSQLWhereTagId );
+	iSQLStatement.AppendNumUC( aTagId );
+	CleanupClosePushL(view1);
+	User::LeaveIfError( view1.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+	User::LeaveIfError( view1.EvaluateAll());
+	// Get column set
+CDbColSet* columns1 = view1.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col           = columns1->ColNo( KTagIdCol );
+	TDbColNo rrdint_col          = columns1->ColNo( KRRDIntCol );
+TDbColNo rrdposition_col1    = columns1->ColNo( KRRDPositionCol );
+	// Cleanup column1 set
+	delete columns1;
+	// Begin process of inserting a row...
+	TInt intarraysize = view1.CountL();
+if ( intarraysize > 0 )
+{
+CArrayFixFlat<TInt>* intArray = new (ELeave) CArrayFixFlat<TInt>(intarraysize);
+CleanupStack::PushL( intArray );
+intArray->ResizeL( intarraysize );
+// set column values for id table...
+for ( view1.FirstL(); view1.AtRow(); view1.NextL() )
+{
+view1.GetL();
+aRRD.SetTagId( view1.ColUint32( tagid_col ) );
+position = view1.ColUint32( rrdposition_col1 );
+if ( position < 0 || position >= intarraysize )
+{
+RUBY_ERROR2("CNssVasDb::FillRRDL position out of bounds. 0 < %i < %i",
+position, intarraysize );
+User::Leave( KErrCorrupt );
+}
+intArray->At( position ) = view1.ColUint32( rrdint_col );
+}
+aRRD.SetIntArrayL( intArray );
+CleanupStack::Pop( intArray );
+intArray->Reset();
+delete intArray;
+}
+	// finished - so close the view
+	view1.Close();
+	CleanupStack::PopAndDestroy( &view1 );
+	CleanupClosePushL(view2);
+	iSQLStatement = KSQLAddRRDText;
+	iSQLStatement.Append( KSQLWhereTagId );
+	iSQLStatement.AppendNumUC( aTagId );
+User::LeaveIfError( view2.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+	User::LeaveIfError( view2.EvaluateAll() );
+// Get column set
+CDbColSet* columns2 = view2.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col2       = columns2->ColNo( KTagIdCol );
+	TDbColNo rrdtext_col2     = columns2->ColNo( KRRDTextCol );
+TDbColNo rrdposition_col2 = columns2->ColNo( KRRDPositionCol );
+	delete columns2;
+	TInt textarraysize = view2.CountL();
+if ( textarraysize > 0 )
+{
+CArrayFixFlat<NssRRDText>* textArray =
+new (ELeave) CArrayFixFlat<NssRRDText>(textarraysize);
+CleanupStack::PushL( textArray );
+textArray->ResizeL( textarraysize );
+//set colum values for text table
+for ( view2.FirstL(); view2.AtRow(); view2.NextL() )
+{
+view2.GetL();
+aRRD.SetTagId( view2.ColUint32( tagid_col2 ) );
+position      = view2.ColUint32( rrdposition_col2 );
+if ( position < 0 || position >= textarraysize )
+{
+RUBY_ERROR2("CNssVasDb::FillRRDL position out of bounds. 0 < %i < %i",
+position, textarraysize );
+User::Leave( KErrCorrupt );
+}
+textArray->At( position ) = view2.ColDes( rrdtext_col2 );
+}
+aRRD.SetTextArrayL( textArray );
+CleanupStack::Pop( textArray );
+textArray->Reset();
+delete textArray;
+}
+	// finished - so close the view
+	view2.Close();
+CleanupStack::PopAndDestroy( &view2 );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagL
+// Gets a tag by grammar ID and rule ID.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagL( TNssGrammarIdRuleId aGrammarIdRuleId )
+{
+	CNssContext* context = iContextBuilder.CreateContextL();
+	CleanupStack::PushL( context );
+	RDbView view;
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+	CleanupClosePushL(view);
+	_LIT( KSQLGetContext, "select * from contexttable where grammarid=");
+	iSQLStatement.Copy(KSQLGetContext);
+	iSQLStatement.AppendNumUC(aGrammarIdRuleId.iGrammarId);
+TDbQuery dbQuery(iSQLStatement, EDbCompareNormal);
+	User::LeaveIfError( view.Prepare( iDatabase, dbQuery ) );
+	User::LeaveIfError( view.EvaluateAll() );
+	view.FirstL();
+FillContextL(view, *context);
+	_LIT( KSQLGetTag, "select * from tagtable where ruleid=");
+	_LIT( KSQLAnd," and contextid=");
+	iSQLStatement = KSQLGetTag;
+	iSQLStatement.AppendNumUC( aGrammarIdRuleId.iRuleId );
+iSQLStatement.Append( KSQLAnd );
+	iSQLStatement.AppendNumUC( context->ContextId() );
+// Close view
+CleanupStack::PopAndDestroy( &view );
+CArrayPtrFlat<CNssTag>* res = GetTagListByQueryL( iSQLStatement );
+// Pop rollback cleanup item
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+CleanupStack::PopAndDestroy( context );
+return( res );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagsL
+// Gets a list of tags by grammar ID and rule ID.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagsL( TNssGrammarIdRuleIdListArray& aGrammarIdRuleIds )
+	{
+	CNssContext* context = iContextBuilder.CreateContextL();
+	CleanupStack::PushL( context );
+	RDbView view;
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+Mem::FillZ( context,     sizeof(*context)   );
+	CleanupClosePushL(view);
+	_LIT( KSQLGetContext, "select * from contexttable where ");
+	_LIT( KGrammarIdParam, "grammarid=" );
+	_LIT( KOr, " OR ");
+	iSQLStatement.Copy(KSQLGetContext);
+	for( TInt i = 0; i < aGrammarIdRuleIds.Count(); i++)
+		{
+		if( i !=0 )
+			{
+			iSQLStatement.Append(KOr);
+			}
+		iSQLStatement.Append(KGrammarIdParam);
+		iSQLStatement.AppendNumUC(aGrammarIdRuleIds[i].iGrammarId);
+		// same grammar ids usually appear, but that's ok and should not decrease performance
+		}
+	TDbQuery dbQuery(iSQLStatement, EDbCompareNormal);
+	User::LeaveIfError( view.Prepare( iDatabase, dbQuery ));
+	User::LeaveIfError( view.EvaluateAll());
+	_LIT( KSQLGetTags, "select * from tagtable where (");
+	_LIT( KRuleId, "ruleid=");
+	_LIT( KContextId,"contextid=");
+	_LIT( KBracketAnd, " AND (");
+	_LIT( KBracketOr, ") OR (");
+	_LIT( KFinalBracket, ")");
+	// Get column set
+CDbColSet* columns = view.ColSetL();
+	TDbColNo contextid_col= columns->ColNo( KContextIdCol );
+	TDbColNo grammarid_col= columns->ColNo( KGrammarIdCol );
+	delete columns;
+	TUint32 currContextId;
+	TUint32 currGrammarId;
+	TUint32 currRuleId;
+	iSQLStatement = KSQLGetTags;
+	TBool firstPair = ETrue;
+	while( view.NextL())
+		{
+		view.GetL();
+		// before each iteration, but first, we add ") OR ("
+		if( firstPair )
+			{
+			firstPair = EFalse;
+			}
+		else
+			{
+			iSQLStatement.Append(KBracketOr);
+			}
+		currContextId = view.ColUint32( contextid_col );
+		currGrammarId = view.ColUint32( grammarid_col );
+		iSQLStatement.Append( KContextId );
+		iSQLStatement.AppendNumUC( currContextId );
+		iSQLStatement.Append( KBracketAnd );
+		// we need to find corresponding rule id
+		TBool someGrammarFoundAlready = EFalse;
+		for( TInt i=0; i<aGrammarIdRuleIds.Count(); i++)
+			{
+			if( currGrammarId == aGrammarIdRuleIds[i].iGrammarId )
+				{
+				if( someGrammarFoundAlready )
+					{
+					iSQLStatement.Append( KOr );
+					}
+				else
+					{
+					someGrammarFoundAlready = ETrue;
+					}
+				currRuleId = aGrammarIdRuleIds[i].iRuleId;
+				iSQLStatement.Append( KRuleId );
+				iSQLStatement.AppendNumUC( currRuleId );
+				}
+			}  // for
+		iSQLStatement.Append(KFinalBracket);  // closing ruleid ORs
+		}  // while
+	// Close view
+CleanupStack::PopAndDestroy( &view );
+iSQLStatement.Append( KFinalBracket );
+CArrayPtrFlat<CNssTag>* res = GetTagListByQueryL( iSQLStatement );
+// Pop rollback cleanup item
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+CleanupStack::PopAndDestroy( context );
+return( res );
+	}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagListByQuery
+// Executes the query and reads matches from DB to memory.
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagListByQuery
+// Executes the query and reads matches from DB to memory.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagListByQueryL( const TDesC& aSqlQuery )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::GetTagListByQueryL" );
+__ASSERT_DEBUG( aSqlQuery.Left(6).Compare( _L("select") ) == 0, User::Panic( KVasDbPanic, __LINE__ ) );
+	CNssContext* context = NULL;
+	CNssSpeechItem* speechItem = NULL;
+	CNssRRD* rrd = NULL;
+TInt contextId = -1;
+// 'context' variable is the context of the previous tag.
+// When a new tag is read, 'context' is updated only if context changes.
+// Set the ID invalid value in order to force the first tag to read a context.
+//context.iContextId = (TUint32)-1;
+//context->SetContextId( -1 );
+	RDbView view;
+	CleanupClosePushL( view );
+CArrayPtrFlat<CNssTag>* tagList = new(ELeave)CArrayPtrFlat<CNssTag>( KMaxTagArraySize );
+CleanupStack::PushL( tagList );
+CleanupResetAndDestroyPushL( *tagList );
+	User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( aSqlQuery, EDbCompareNormal ) ) );
+	User::LeaveIfError( view.EvaluateAll() );
+	if ( !view.IsEmptyL() )
+	    {
+	    for (view.FirstL(); view.AtRow(); view.NextL())
+	        {
+	        context = iContextBuilder.CreateContextL();
+	        CleanupStack::PushL( context );
+	        speechItem = iSpeechItemBuilder.CreateEmptySpeechItemL( *context );
+	        CleanupStack::PushL( speechItem );
+FillSpeechItemL( view, *speechItem, contextId );
+// Get context, if we haven't already done it.
+if ( context->ContextId() != (TUint32)contextId )
+{
+_LIT( KContextQuery, "select * from contexttable where contextid=" );
+iSQLStatement.Copy( KContextQuery );
+iSQLStatement.AppendNumUC( contextId );
+CArrayPtrFlat<CNssContext>* contextList =
+GetContextInsideTransactionL( iSQLStatement );
+CleanupStack::PushL( contextList );
+User::LeaveIfNull( contextList );
+if ( contextList->Count() != 1 )
+{
+User::Leave( KErrCorrupt );
+}
+CleanupStack::Pop( contextList );
+CleanupStack::PopAndDestroy( speechItem );
+CleanupStack::PopAndDestroy( context );
+context = (*contextList)[0];
+delete contextList;
+CleanupStack::PushL( context );
+	            speechItem = iSpeechItemBuilder.CreateEmptySpeechItemL( *context );
+	            CleanupStack::PushL( speechItem );
+FillSpeechItemL( view, *speechItem, contextId );
+}
+rrd = CNssRRD::NewL();
+CleanupStack::PushL( rrd );
+FillRRDL( speechItem->TagId(), *rrd );
+// Append tag to the array
+FillTagListArrayL( *tagList, context, speechItem, rrd );
+CleanupStack::PopAndDestroy( rrd );
+CleanupStack::PopAndDestroy( speechItem );
+CleanupStack::PopAndDestroy( context );
+}
+}
+	else
+	    {
+User::Leave( KErrNotFound );
+	    }
+	CleanupStack::Pop( tagList );  // ResetAndDestroy
+CleanupStack::Pop( tagList );  // array itself
+	// Finished with the view - so close it.
+CleanupStack::PopAndDestroy( &view );
+return tagList;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagL
+// Gets a tag by name.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagL(const TDesC& aName)
+{
+_LIT( KTick,"' ");
+	_LIT( KSQLGetTag, "select * from tagtable where name='");
+	iSQLStatement = KSQLGetTag;
+	iSQLStatement.Append( aName );
+iSQLStatement.Append( KTick );
+User::LeaveIfError( StartTransaction() );
+CArrayPtrFlat<CNssTag>* arr = GetTagListByQueryL( iSQLStatement );
+CommitTransaction( EFalse );
+return arr;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagL
+// Gets all tags from a specified context.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagL( const CNssContext& aContext)
+{
+RDbView view;
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+CleanupClosePushL( view );
+	// Validate the context
+_LIT( KSQLGetContext, "select * from contexttable where contextid=");
+	iSQLStatement = KSQLGetContext;
+	iSQLStatement.AppendNumUC( aContext.ContextId() );
+	User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+	User::LeaveIfError( view.EvaluateAll() );
+if ( view.IsEmptyL() )
+	    {
+User::Leave( KErrNotFound );
+	    }
+	// Finished with the view - so close it.
+CleanupStack::PopAndDestroy( &view );
+	_LIT( KSQLGetTag, "select * from tagtable where contextid=" );
+	iSQLStatement.Copy( KSQLGetTag );
+	iSQLStatement.AppendNumUC( aContext.ContextId() );
+CArrayPtrFlat<CNssTag>* result = GetTagListByQueryL( iSQLStatement );
+// Transaction finished - free the transaction lock
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+return result;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::GetTagListFromViewL
+// Reads the tags from DB to memory and appends them to the array.
+// Earlier, the caller has made an SQL query and placed the matches in RDbView.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::GetTagListFromViewL( RDbView& aView, CArrayPtrFlat<CNssTag>* aTagList,
+CNssContext* aContext )
+{
+TInt discardable( 0 );
+	for ( aView.FirstL(); aView.AtRow(); aView.NextL() )
+	{
+	CNssSpeechItem* speechItem = iSpeechItemBuilder.CreateEmptySpeechItemL( *aContext );
+	CleanupStack::PushL( speechItem );
+	    FillSpeechItemL( aView, *speechItem, discardable );
+		CNssRRD* rrd = CNssRRD::NewL();
+		CleanupStack::PushL( rrd );
+		FillRRDL( speechItem->TagId(), *rrd );
+		FillTagListArrayL( *aTagList, aContext, speechItem, rrd );
+		CleanupStack::PopAndDestroy( rrd );
+		CleanupStack::PopAndDestroy( speechItem );
+	    }
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteTagL
+// Gets a list of tags by RRD data.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagL( TInt aContextId, TInt aNum, TInt aPosition )
+{
+	RDbView     view;
+	TUint32     tagId;
+	CNssContext* context = iContextBuilder.CreateContextL();
+	CleanupStack::PushL( context );
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+CArrayPtrFlat<CNssTag>* tagArray = new(ELeave)CArrayPtrFlat<CNssTag>(1);
+CleanupStack::PushL( tagArray );
+CleanupResetAndDestroyPushL( *tagArray );
+// Get the context based on ContextId
+	CleanupClosePushL(view);
+	_LIT( KSQLGetContext, "select * from contexttable where contextid=" );
+	iSQLStatement.Copy( KSQLGetContext );
+	iSQLStatement.AppendNumUC( aContextId );
+	User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+	User::LeaveIfError( view.EvaluateAll() );
+	view.FirstL();
+view.GetL();
+	TRAPD( error, FillContextL( view, *context ) );
+	// Finished with the view - so close it.
+	view.Close();
+	CleanupStack::PopAndDestroy( &view );
+// If filling of the context failed, return with Not Found
+	if ( error != KErrNone )
+	    {
+User::Leave( KErrNotFound );
+}
+// Get the list of TagId from the RRD table based on Num and Position
+	RDbView view1;
+	CleanupClosePushL( view1 );
+	_LIT( KSQLGetRRDInt, "select * from rrdinttable where rrdposition=" );
+	_LIT( KSQLAndRRDInt, " and rrdint=" );
+	iSQLStatement = KSQLGetRRDInt;
+	iSQLStatement.AppendNumUC( aPosition );
+	iSQLStatement.Append( KSQLAndRRDInt );
+	iSQLStatement.AppendNumUC( aNum );
+	User::LeaveIfError( view1.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+	User::LeaveIfError( view1.EvaluateAll() );
+	if ( view1.IsEmptyL() )
+	    {
+User::Leave( KErrNotFound );
+	    }
+// Get column set
+CDbColSet* columns = view1.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col= columns->ColNo( KTagIdCol );
+// Cleanup column set
+delete columns;
+// Select the valid tagId from the list
+	for ( view1.FirstL(); view1.AtRow(); view1.NextL() )
+{
+view1.GetL();
+tagId = view1.ColUint32( tagid_col );
+// Get the SpeechItem based on the tagId and ContextId
+RDbView view2;
+		CleanupClosePushL( view2 );
+_LIT( KSQLGetSpeechItem, "select * from tagtable where tagid=" );
+_LIT( KSQLAndContextId," and contextid=" );
+iSQLStatement = KSQLGetSpeechItem;
+iSQLStatement.AppendNumUC( tagId );
+	    iSQLStatement.Append( KSQLAndContextId );
+iSQLStatement.AppendNumUC( aContextId );
+User::LeaveIfError( view2.Prepare( iDatabase,
+TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view2.EvaluateAll() );
+if ( !view2.IsEmptyL() )
+	        {
+GetTagListFromViewL( view2, tagArray, context );
+		    }
+view2.Close();
+CleanupStack::PopAndDestroy( &view2 );
+}
+// close the view 1
+	view1.Close();
+	CleanupStack::PopAndDestroy( &view1 );
+CleanupStack::Pop( tagArray );  // ResetAndDestroy
+CleanupStack::Pop( tagArray );  // array itself
+// Rollback cleanup
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+CleanupStack::PopAndDestroy( context );
+return tagArray;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteTagL
+// Gets a list of tags by RRD data.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagL( TInt aContextId,
+const TDesC& aText, TInt aPosition )
+{
+	RDbView view;
+	TUint32 tagId;
+	CNssContext* context = iContextBuilder.CreateContextL();
+	CleanupStack::PushL( context );
+CArrayPtrFlat<CNssTag>* tagArray = new(ELeave)CArrayPtrFlat<CNssTag>(1);
+CleanupStack::PushL( tagArray );
+CleanupResetAndDestroyPushL( *tagArray );
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+// Get the context based on ContextId
+	CleanupClosePushL( view );
+	_LIT( KSQLGetContext, "select * from contexttable where contextid=" );
+	iSQLStatement.Copy( KSQLGetContext );
+	iSQLStatement.AppendNumUC( aContextId );
+	User::LeaveIfError( view.Prepare(iDatabase, TDbQuery(iSQLStatement, EDbCompareNormal)));
+	User::LeaveIfError( view.EvaluateAll());
+	view.FirstL();
+view.GetL();
+	TRAPD( error, FillContextL( view, *context ) );
+	// Finished with the view - so close it.
+	view.Close();
+	CleanupStack::PopAndDestroy( &view );
+// If filling of the context failed, return with Not Found
+	if ( error != KErrNone )
+	    {
+User::Leave( KErrNotFound );
+}
+// Get the list of TagId from the RRD table based on text and Position
+	RDbView view1;
+	CleanupClosePushL( view1 );
+	_LIT( KSQLGetRRDText, "select * from rrdtexttable where rrdposition=" );
+	_LIT( KSQLAndRRDText, " and rrdtext='" );
+	_LIT( KSQLTick, "'" );
+	iSQLStatement = KSQLGetRRDText;
+	iSQLStatement.AppendNumUC( aPosition );
+	iSQLStatement.Append( KSQLAndRRDText );
+	iSQLStatement.Append( aText );
+iSQLStatement.Append( KSQLTick );
+	User::LeaveIfError( view1.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+	User::LeaveIfError( view1.EvaluateAll() );
+	if ( view1.IsEmptyL() )
+	    {
+User::Leave( KErrNotFound );
+	    }
+// Get column set
+CDbColSet* columns = view1.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col= columns->ColNo( KTagIdCol );
+// Cleanup column set
+delete columns;
+// Select the valid tagId from the list
+	for ( view1.FirstL(); view1.AtRow(); view1.NextL() )
+	    {
+view1.GetL();
+tagId = view1.ColUint32( tagid_col );
+// Get the SpeechItem based on the tagId and ContextId
+RDbView view2;
+		CleanupClosePushL( view2 );
+_LIT( KSQLGetSpeechItem, "select * from tagtable where tagid=" );
+_LIT( KSQLAndContextId, " and contextid=" );
+iSQLStatement = KSQLGetSpeechItem;
+iSQLStatement.AppendNumUC( tagId );
+	    iSQLStatement.Append( KSQLAndContextId );
+iSQLStatement.AppendNumUC( aContextId );
+User::LeaveIfError( view2.Prepare( iDatabase,
+TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view2.EvaluateAll() );
+if ( !view2.IsEmptyL() )
+	        {
+GetTagListFromViewL( view2, tagArray, context );
+		    }
+CleanupStack::PopAndDestroy( &view2 );
+}
+// close the view 1
+	CleanupStack::PopAndDestroy( &view1 );
+// Roll back transaction
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+CleanupStack::Pop( tagArray );  // ResetAndDestroyPushL
+CleanupStack::Pop( tagArray );  // array itself
+CleanupStack::PopAndDestroy( context );
+return tagArray;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteTagL
+// Get a tag by ID.
+// -----------------------------------------------------------------------------
+//
+CArrayPtrFlat<CNssTag>* CNssVasDb::GetTagL( TUint32 aTagId )
+{
+	RDbView view;
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+CleanupClosePushL( view );
+	_LIT( KSQLGetTag, "select * from tagtable where tagid=");
+	iSQLStatement = KSQLGetTag;
+	iSQLStatement.AppendNumUC( aTagId );
+CArrayPtrFlat<CNssTag>* result = GetTagListByQueryL( iSQLStatement );
+// Close view
+CleanupStack::PopAndDestroy( &view );
+// Roll back transaction
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( EFalse );
+return( result );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteTagL
+// Deletes a tag by name
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::DeleteTagL( const TDesC& aName )
+{
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+TUint32 tagId;
+RDbView view;
+CleanupClosePushL(view);
+_LIT( KTick,"' ");
+_LIT( KSQLGetTag, "select * from tagtable where name='");
+iSQLStatement = KSQLGetTag;
+iSQLStatement.Append( aName );
+iSQLStatement.Append( KTick );
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery(iSQLStatement, EDbCompareNormal)));
+User::LeaveIfError( view.EvaluateAll());
+// Get column set
+CDbColSet* columns = view.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col= columns->ColNo( KTagIdCol );
+// Cleanup column set
+delete columns;
+view.FirstL();
+view.GetL();
+tagId = view.ColUint32( tagid_col );
+// Close view
+CleanupStack::PopAndDestroy( &view );
+// Pop rollback item and do commit
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( ETrue );
+DeleteTagL( tagId );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteTagL
+// Deletes a tag by ID
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::DeleteTagL( TUint32 aTagId )
+{
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "CNssVasDb error: database not opened." );
+User::Leave( KErrNotReady );
+}
+// Lock database
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+DeleteTagInsideTransactionL( aTagId );
+// Commit transaction - unlock databaes
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( ETrue );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteTagInsideTransactionL
+// Deletes the RRD information of a tag.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::DeleteTagInsideTransactionL( TUint32 aTagId )
+{
+TInt error( KErrNone );
+_LIT( KSQLDeleteTag, "delete from tagtable where tagid=");
+	ReserveDiskSpaceL( sizeof(CNssTag) );
+iSQLStatement = KSQLDeleteTag;
+iSQLStatement.AppendNumUC(aTagId);
+error = iDatabase.Execute( iSQLStatement );
+if ( error < KErrNone )
+{
+ReleaseDiskSpace();
+User::Leave( error );
+}
+TRAP( error, DeleteRRDL( aTagId ) );
+ReleaseDiskSpace();
+User::LeaveIfError( error );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteRRDL
+// Deletes the RRD information of a tag.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::DeleteRRDL(TUint32 aTagId)
+{
+TInt error( KErrNone );
+_LIT( KSQLAddRRDText, "delete from rrdtexttable ");
+_LIT( KSQLAddRRDId,   "delete from rrdinttable ");
+_LIT( KSQLWhereTagId,"where tagid=");
+iSQLStatement = KSQLAddRRDId;
+iSQLStatement.Append( KSQLWhereTagId );
+iSQLStatement.AppendNumUC( aTagId );
+error = iDatabase.Execute( iSQLStatement );
+if ( error < KErrNone && error != KErrNotFound )
+{
+User::Leave( error );
+}
+iSQLStatement = KSQLAddRRDText;
+iSQLStatement.Append( KSQLWhereTagId );
+iSQLStatement.AppendNumUC( aTagId );
+error = iDatabase.Execute( iSQLStatement );
+if ( error < KErrNone && error != KErrNotFound )
+{
+User::Leave( error );
+}
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DeleteContextL
+// Deletes a context.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::DeleteContextL( const TDesC& aName )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::DeleteContextL" );
+TInt error( KErrNone );
+TUint32 contextId;
+TUint32 tagId;
+RDbView view1,view2;
+// Begin transaction
+User::LeaveIfError( StartTransaction() );
+CreatePushRollbackItemLC();
+CleanupClosePushL( view1 );
+// Search the context from DB
+_LIT( KTick, "' " );
+_LIT( KSQLGetContext, "select * from contexttable where name='" );
+iSQLStatement = KSQLGetContext;
+iSQLStatement.Append( aName );
+iSQLStatement.Append( KTick );
+User::LeaveIfError( view1.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view1.EvaluateAll() );
+// Get column set
+CDbColSet* columns1 = view1.ColSetL();
+// Get column ordinals
+TDbColNo contextid_col= columns1->ColNo( KContextIdCol );
+// Cleanup column set
+delete columns1;
+view1.FirstL();
+// Doesn't exists, can't delete
+if ( !view1.AtRow() )
+{
+User::Leave( KErrNotFound );
+}
+view1.GetL();
+contextId = view1.ColUint32( contextid_col );
+view1.DeleteL();
+view1.Close();
+CleanupStack::PopAndDestroy( &view1 );
+// Delete all tags, which were in the context.
+_LIT( KSQLGetTag, "select * from tagtable where contextid=" );
+iSQLStatement = KSQLGetTag;
+iSQLStatement.AppendNumUC( contextId );
+CleanupClosePushL( view2 );
+User::LeaveIfError( view2.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view2.EvaluateAll() );
+ReserveDiskSpaceL( (sizeof(CNssTag) * view2.CountL()) + sizeof(CNssContext) );
+view2.FirstL();
+// If this context has any tags, remove the RRD entries from the RRD table.
+if ( view2.AtRow() )
+{
+// Get column set
+CDbColSet* columns2 = view2.ColSetL();
+// Get column ordinals
+TDbColNo tagid_col = columns2->ColNo( KTagIdCol );
+// Cleanup column2 set
+delete columns2;
+for ( view2.FirstL(); view2.AtRow(); view2.NextL() )
+{
+view2.GetL();
+tagId = view2.ColUint32( tagid_col );
+RUBY_DEBUG0( "CNssVasDb::DeleteContextL deleting RRD" );
+// Return value ignored since other tag ids should be iterated through
+// even though one RRD deletion fails
+TRAP( error, DeleteRRDL( tagId ) );
+}
+view2.Close();
+}
+// Remove tags from tag table
+_LIT( KSQLDeleteTag, "delete from tagtable where contextid=");
+iSQLStatement = KSQLDeleteTag;
+iSQLStatement.AppendNumUC( contextId );
+error = iDatabase.Execute( iSQLStatement );
+CleanupStack::PopAndDestroy( &view2 );
+if ( error < KErrNone && error != KErrNotFound )
+{
+ReleaseDiskSpace();
+// Roll back transaction
+CleanupStack::PopAndDestroy(); // Rollback cleanup item
+User::Leave( error );
+}
+CleanupStack::Pop();  // Rollback cleanup item
+CommitTransaction( ETrue );
+ReleaseDiskSpace();
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateTagInTransactionL
+// Updates a tag. Assumes that a transaction has been started earlier.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateTagInTransactionL( CNssTag& aTag )
+{
+CNssContext* context = static_cast<CNssContext*> ( aTag.Context() );
+UpdateContextInsideTransactionL( *context );
+CNssSpeechItem* speechItem = static_cast<CNssSpeechItem*>
+( aTag.SpeechItem() );
+UpdateSpeechItemL( *speechItem );
+CNssRRD* rrd = static_cast<CNssRRD*> ( aTag.RRD() );
+UpdateRRDL( *rrd );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DoUpdateContextL
+// Updates an existing context.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::DoUpdateContextL( CNssContext& aContext )
+{
+_LIT( KSQLUpdateContext,"update contexttable set ");
+_LIT( KEqual,"=");
+_LIT( KCommon,",");
+_LIT( KTick,"'");
+_LIT( KSQLWhereContextId," where contextid = ");
+iSQLStatement = KSQLUpdateContext;
+iSQLStatement.Append( KNameCol );
+iSQLStatement.Append( KEqual );
+iSQLStatement.Append( KTick );
+iSQLStatement.Append( aContext.ContextName() );
+iSQLStatement.Append( KTick );
+iSQLStatement.Append( KCommon );
+iSQLStatement.Append( KGlobalCol );
+iSQLStatement.Append( KEqual );
+iSQLStatement.AppendNumUC( aContext.IsGlobal() );
+iSQLStatement.Append( KCommon );
+iSQLStatement.Append( KGrammarIdCol );
+iSQLStatement.Append( KEqual );
+iSQLStatement.AppendNumUC( aContext.GrammarId() );
+iSQLStatement.Append( KCommon );
+iSQLStatement.Append( KLexiconIdCol );
+iSQLStatement.Append( KEqual );
+iSQLStatement.AppendNumUC( aContext.LexiconId() );
+iSQLStatement.Append( KCommon );
+iSQLStatement.Append( KModelBankIdCol );
+iSQLStatement.Append( KEqual );
+iSQLStatement.AppendNumUC( aContext.ModelBankId() );
+iSQLStatement.Append( KSQLWhereContextId );
+iSQLStatement.AppendNumUC( aContext.ContextId() );
+User::LeaveIfError( iDatabase.Execute( iSQLStatement ) );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::DoUpdateUpdateContextClientDataL
+// Updates the client data of a context.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::DoUpdateContextClientDataL( CNssContext& aContext )
+{
+	__UHEAP_MARK;
+	// Declare a literal string to hold the SQL statement
+	// SELECT KBinaryLexiconColumn , KBinaryLexiconColumn FROM  KLexiconName
+	_LIT( KSQLSelect1, "select clientdata from contexttable where name='" );
+	TBuf<KSqlStatementmaxLength> sqlStatement;
+	sqlStatement.Append( KSQLSelect1 );
+sqlStatement.Append( aContext.ContextName() );
+sqlStatement.Append( '\'' );
+	// create a view on the database
+	RDbView view;
+CleanupClosePushL( view ); // Stack: view
+	User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( sqlStatement, EDbCompareNormal ) ) );
+	User::LeaveIfError( view.EvaluateAll() );
+	// Get the structure of rowset
+	CDbColSet* colSet = view.ColSetL();
+CleanupStack::PushL( colSet ); // Stack: view, colset
+TInt error( KErrNone );
+	if( view.FirstL() )
+		{
+		view.UpdateL();
+		// add binary buffer by Using the stream
+		//RDbColWriteStream out;
+		TDbColNo col = colSet->ColNo( _L("clientdata") ); // Ordinal position of client data
+	if ( col == KDbNullColNo )
+	{
+	User::Leave( KErrCorrupt );
+	}
+	view.SetColL( col, aContext.ClientData() );
+		view.PutL();
+		// close the view
+	view.Close();
+		}
+	else
+		{
+		error = KErrNotFound;
+		}
+CleanupStack::PopAndDestroy( colSet );
+CleanupStack::PopAndDestroy( &view );
+	__UHEAP_MARKEND;
+User::LeaveIfError( error );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateRRDL
+// Updates an existing RRD.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateRRDL( CNssRRD& aRRD )
+{
+TRAPD( error, DeleteRRDL( aRRD.TagId() ) );
+if ( error != KErrNotFound)
+{
+error = KErrNone;
+}
+User::LeaveIfError( error );
+SaveRRDL( &aRRD );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UpdateSpeechItemL
+// Updates an existing speech item.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UpdateSpeechItemL( CNssSpeechItem& aSpeechItem )
+{
+RDbView view;
+CleanupClosePushL( view );
+_LIT( KSQLGet, "select * from tagtable where tagid=" );
+iSQLStatement = KSQLGet;
+iSQLStatement.AppendNumUC( aSpeechItem.TagId() );
+User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );
+User::LeaveIfError( view.EvaluateAll());
+// Get column set
+CDbColSet* columns = view.ColSetL();
+// Get column ordinals
+TDbColNo name_col= columns->ColNo( KNameCol );
+delete columns;
+if ( view.FirstL() )
+{
+// Begin process of updating a row...
+view.UpdateL();
+// set column values...
+#ifdef __SIND_EXTENSIONS
+view.SetColL( name_col, aSpeechItem.RawText() );
+#else
+view.SetColL( name_col, aSpeechItem.Text() );
+#endif
+// add the row to the table...
+view.PutL();
+// finished - so close the view
+view.Close();
+		}
+else
+{
+User::Leave( KErrNotFound );
+}
+CleanupStack::PopAndDestroy( &view );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::FillSpeechItemL
+// Reads a TNssSpeechItem from DB to memory. Earlier, the caller has run an SQL
+// query and specifies the matching context in RDbView.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::FillSpeechItemL( RDbView& aView, CNssSpeechItem& aSpeechItem, TInt& aContextId )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::FillSpeechItemL" );
+	if ( aView.IsEmptyL() )
+	    {
+		User::Leave( KErrNotFound );
+	    }
+	// Get column set
+CDbColSet* columns = aView.ColSetL();
+// Get column ordinals
+	TDbColNo tagid_col    = columns->ColNo( KTagIdCol );
+	TDbColNo contextid_col= columns->ColNo( KContextIdCol );
+	TDbColNo ruleid_col   = columns->ColNo( KRuleIdCol );
+	TDbColNo name_col     = columns->ColNo( KNameCol );
+// Cleanup column set
+delete columns;
+	// Retrieve the current row
+	aView.GetL();
+	aSpeechItem.SetTagId( aView.ColUint32( tagid_col ) );
+	aSpeechItem.SetRuleID( aView.ColUint32( ruleid_col ) );
+	aSpeechItem.SetTextL( aView.ColDes( name_col ) );
+aContextId = aView.ColUint32( contextid_col );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::FillContextL
+// Reads a context from DB to memory. Earlier, the caller has run an SQL query
+// and specifies the matching context in RDbView.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::FillContextL( RDbView& aView, CNssContext& aContext )
+{
+if ( aView.IsEmptyL() )
+	    {
+	    User::Leave( KErrNotFound );
+	    }
+	// Get column set
+CDbColSet* columns = aView.ColSetL();
+// Get column ordinals
+	TDbColNo contextid_col= columns->ColNo( KContextIdCol );
+	TDbColNo name_col = columns->ColNo( KNameCol );
+TDbColNo global_col = columns->ColNo( KGlobalCol );
+	TDbColNo grammarid_col= columns->ColNo( KGrammarIdCol );
+	TDbColNo lexiconid_col= columns->ColNo( KLexiconIdCol );
+	TDbColNo modelbankid_col= columns->ColNo( KModelBankIdCol );
+// Cleanup column set
+delete columns;
+	// Retrieve the current row
+	aView.GetL();
+	aContext.SetContextId( aView.ColUint32( contextid_col ) );
+	aContext.SetGlobal( aView.ColUint32( global_col ) );
+	aContext.SetGrammarId( aView.ColUint32( grammarid_col ) );
+	aContext.SetLexiconId( aView.ColUint32( lexiconid_col ) );
+	aContext.SetModelBankId( aView.ColUint32( modelbankid_col ) );
+	aContext.SetNameL( aView.ColDes( name_col ) );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::FillTagListArrayL
+// Creates a TNssTag from context, speech item and RRD information.
+// Adds a tag to aTagList.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::FillTagListArrayL( CArrayPtrFlat<CNssTag>& aTagList, CNssContext* aContext,
+CNssSpeechItem* aSpeechItem, CNssRRD* aRRD )
+{
+CNssContext* contextCopy = aContext->CopyL();
+CNssSpeechItem* speechItenCopy = aSpeechItem->CopyL( contextCopy );
+CNssRRD* rrdCopy = aRRD->CopyL();
+CNssTag* tag = new (ELeave) CNssTag( contextCopy, rrdCopy, speechItenCopy );
+tag->SetTagId( aSpeechItem->TagId() );
+	aTagList.AppendL( tag );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::FillContextListArrayL
+// Utility function to read contexts from DB to memory. Earlier, the caller has
+// run an SQL query and the matches are listed in an RDbView.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::FillContextListArrayL( RDbView& aView, CArrayPtrFlat<CNssContext>& aContextList )
+{
+RUBY_DEBUG_BLOCK("CNssVasDb::FillContextListArrayL");
+	TInt pos( 0 );
+	// Clear the previous array.
+	aContextList.Reset();
+// Get column set
+CDbColSet* columns = aView.ColSetL();
+// Get column ordinals
+TDbColNo name_col       = columns->ColNo( KNameCol );
+TDbColNo global_col     = columns->ColNo( KGlobalCol );
+	TDbColNo grammarid_col  = columns->ColNo( KGrammarIdCol );
+	TDbColNo lexiconid_col  = columns->ColNo( KLexiconIdCol );
+	TDbColNo modelbankid_col= columns->ColNo( KModelBankIdCol );
+	TDbColNo contextid_col  = columns->ColNo( KContextIdCol );
+// New in 2.8
+TDbColNo clientdata_col = columns->ColNo( KClientDataCol );
+	delete columns;
+	for (aView.FirstL(); aView.AtRow(); aView.NextL())
+	    {
+	    aView.GetL(); // Retrieve the current row - actually reads the row from the database.
+CNssContext* oneContext = iContextBuilder.CreateContextL();
+CleanupStack::PushL( oneContext );
+oneContext->SetNameL( aView.ColDes( name_col ) );
+oneContext->SetGlobal( aView.ColUint32( global_col ) );
+oneContext->SetContextId( aView.ColUint32( contextid_col ) );
+oneContext->SetLexiconId( aView.ColUint32( lexiconid_col ) );
+oneContext->SetGrammarId( aView.ColUint32( grammarid_col ) );
+oneContext->SetModelBankId( aView.ColUint32( modelbankid_col ) );
+oneContext->SetClientData( aView.ColDes8( clientdata_col ) );
+	    // Now add the context object to the list (array) of context.
+	    aContextList.InsertL( pos++, oneContext );
+	    // Copy has been created in aContextList, no need for pointer anymore
+	    CleanupStack::Pop( oneContext );
+	    }
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::StartTransactionL
+// Starts a new transaction.
+// -----------------------------------------------------------------------------
+//
+TInt CNssVasDb::StartTransaction()
+{
+RUBY_DEBUG0( "CNssVasDb::StartTransaction" );
+if ( !iClientHasOpenedDatabase )
+{
+RUBY_DEBUG0( "No open DB. E.g. backup/restore in progress" );
+return KErrNotReady;
+}
+__ASSERT_DEBUG( iLocked == iDatabase.InTransaction(), User::Panic( KVasDbPanic, __LINE__ ) );
+iCriticalSection.Wait();
+if ( iLocked )
+{
+// If we already have the lock, no need to take it again
+RUBY_DEBUG0( "CNssVasDb::StartTransaction DB is already locked by current process" );
+return KErrNone;
+}
+// Wait for the mutex so that two processes don't try get the lock simultaneously
+RUBY_DEBUG0( "Waiting for mutex in CNssVasDb::StartTransaction" );
+iMutex.Wait();
+// check if backup is ongoing
+TInt readLockErr = iDatabase.Begin();
+// Mutex should make it sure that we have exclusive lock to Database
+// Thus iDatabase.Begin() should succeed every time
+__ASSERT_DEBUG( readLockErr == KErrNone, User::Panic( KVasDbPanic, __LINE__ ) );
+if ( readLockErr == KErrNone )
+{
+iLocked = ETrue;
+}
+RUBY_DEBUG0( "CNssVasDb::StartTransaction completed" );
+return readLockErr;
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::CommitTransaction
+// Commits changes and releases the lock. If iShouldBeLocked flag is set,
+// opens a new tranaction in order to keep the database locked.
+// -----------------------------------------------------------------------------
+//
+TInt CNssVasDb::CommitTransaction( TBool aCompact )
+{
+RUBY_DEBUG0( "CNssVasDb::CommitTransaction" );
+__ASSERT_DEBUG( iLocked == iDatabase.InTransaction(), User::Panic( KVasDbPanic, __LINE__ ) );
+//__ASSERT_DEBUG( iLocked, User::Panic( _L("VasCNssVasDb.cpp"), __LINE__ ) );
+TInt ret = KErrNone;
+if ( iLocked )
+{
+ret = iDatabase.Commit();
+if ( iDatabase.IsDamaged() )
+{
+RUBY_DEBUG0( "CNssVasDb::CommitTransaction Recovering" );
+ret = iDatabase.Recover();
+}
+if ( aCompact )
+{
+RUBY_DEBUG0( "CNssVasDb::CommitTransaction compacting DB" );
+iDatabase.Compact();
+}
+iLocked = EFalse;
+RUBY_DEBUG0( "Signalling mutex in CNssVasDb::CommitTransaction" );
+iMutex.Signal();
+}
+else
+{
+RUBY_DEBUG0( "ERROR: CNssVasDb::CommitTransaction does nothing, not locked" );
+}
+iCriticalSection.Signal();
+return( ret );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::RollbackTransaction
+// Discards changes and releases the lock.
+// -----------------------------------------------------------------------------
+//
+TInt CNssVasDb::RollbackTransaction()
+{
+__ASSERT_DEBUG( iLocked == iDatabase.InTransaction(), User::Panic( KVasDbPanic, __LINE__ ) );
+__ASSERT_DEBUG( iLocked, User::Panic( KVasDbPanic, __LINE__ ) );
+TInt ret = KErrNone;
+iDatabase.Rollback();
+iLocked = EFalse;
+if ( iDatabase.IsDamaged() )
+{
+RUBY_DEBUG0( "CNssVasDb::RollbackTransaction Recovering" );
+ret = iDatabase.Recover();
+}
+RUBY_DEBUG0( "Signalling mutex in CNssVasDb::RollbackTransaction" );
+iMutex.Signal();
+iCriticalSection.Signal();
+return( ret );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::LockTransactionsL
+// Permit transactions and release database
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::LockTransactionsL()
+{
+// lock transactions
+RUBY_DEBUG_BLOCK( "CNssVasDb::LockTransactionsL" );
+iCriticalSection.Wait(); // wait until a possible transaction ends
+// release a database
+CloseDatabase();
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::UnlockTransactionsL
+// Allow transactions and reserve database
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::UnlockTransactionsL()
+{
+// unlock transactions
+RUBY_DEBUG_BLOCK( "CNssVasDb::UnlockTransactionsL" );
+OpenDatabaseL(); // open database
+if ( iCriticalSection.IsBlocked() )
+{
+iCriticalSection.Signal(); // allow to do transactions
+}
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::ReserveDiskSpaceL(
+// Reserves disk space. Leaves (KErrDiskFull), if not
+// enough space.
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::ReserveDiskSpaceL( TInt aRequestSize )
+{
+RUBY_DEBUG_BLOCK( "CNssVasDb::ReserveDiskSpaceL" );
+#ifdef _DEBUG
+TInt error = iDbSession.ReserveDriveSpace( iDrive, aRequestSize );
+if ( error )
+{
+RUBY_DEBUG1( "CNssVasDb::ReserveDiskSpaceL fails %d", error );
+User::Leave( error );
+}
+#else
+User::LeaveIfError( iDbSession.ReserveDriveSpace( iDrive, aRequestSize ) );
+#endif // _DEBUG
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::ReleaseDiskSpace
+// Releases the disk space
+// -----------------------------------------------------------------------------
+//
+void CNssVasDb::ReleaseDiskSpace()
+{
+RUBY_DEBUG0( "CNssVasDb::ReleaseDiskSpace" );
+iDbSession.FreeReservedSpace( iDrive );
+}
+// -----------------------------------------------------------------------------
+// CNssVasDb::CreateRollbackItemLC
+// Creates a cleanup item and pushes it to the cleanup stack. In case of a
+// leave, PopAndDestroying this item will call RollbackCleanupFunction
+// -----------------------------------------------------------------------------
+void CNssVasDb::CreatePushRollbackItemLC()
+{
+TCleanupItem item( RollbackCleanupFunction, this );
+CleanupStack::PushL( item );
+}
+// End of file

branch	RCL_3
changeset 19	e36f3802f733