1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  This class is responsible for managing all database access

    15 *                databases.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 

    22 #include <sqldb.h>

    23 #include <badesca.h>

    24 #include <f32file.h>

    25 // PREQ2536 the files sqlrowsetutil.h and sqlrowsetutil.cpp has been removed

    26 //#ifdef __WINSCW__    

    27 //#include <sqlrowsetutil.h>

    28 //#endif

    29 #include <sysutil.h>

    30 

    31 #include <mpxlog.h>

    32 

    33 #include "mpxdbcommondef.h"

    34 #include "mpxtable.h"

    35 #include "mpxdbmanager.h"

    36 

    37 // CONSTANTS

    38 

    39 // Version of   Database

    40 const   TInt KMPXDbVersion[] = {6,0,0};

    41 

    42 _LIT8( KMCSqlConfig, "cache_size=1024; page_size=16384; " );

    43 

    44 _LIT(KSecureFilePath,   "%S[%x]%S");

    45 _LIT(KRootDrive, "C:");

    46 _LIT(KAliasName, "%1SDrive");

    47 _LIT(KBeginTransaction, "BEGIN TRANSACTION");

    48 _LIT(KCommitTransaction, "COMMIT TRANSACTION");

    49 _LIT(KRollbackTransaction, "ROLLBACK TRANSACTION");

    50 _LIT(KOrderByToken, "ORDER BY");

    51 _LIT(KDBNameToken, ":dbname");

    52 _LIT(KPlDBNameToken, ":pldbname");

    53 _LIT(KUnionAllToken, " UNION ALL ");

    54 _LIT(KSelectToken, "SELECT");

    55 

    56 //for database deletion

    57 _LIT( KDBFilePath, "\\private\\10281e17\\" );

    58 _LIT( KDBFilePattern, "*.db*" );    

    59 

    60 #ifdef _DEBUG

    61 _LIT(KTableQuery, "SELECT * FROM %S");

    62 _LIT(KAttachedTableQuery, "SELECT * FROM :dbname.%S");

    63 _LIT(KFindAllCDriveTablesQuery, "SELECT name FROM   sqlite_master WHERE type = 'table' ORDER BY name");

    64 _LIT(KFindAllAttachedTablesQuery, "SELECT name FROM :dbname.sqlite_master WHERE type = 'table' ORDER BY name");

    65 _LIT(KNameColumn, "name");

    66 #endif

    67 

    68 const TInt KMaxLogQuery = 248;

    69 const TInt KBufIncrement = 10;

    70 

    71 // Used to suppress overflow when appending formatted text to a buffer.

    72 class TOverflowHandle :

    73     public TDesOverflow

    74     {

    75     public:

    76         TOverflowHandle() :

    77             iFlag(EFalse)

    78             {

    79             }

    80 

    81         virtual void Overflow(TDes& /* aDes */)

    82             {

    83             iFlag = ETrue;

    84             return;

    85             }

    86 

    87         TBool GetOverflowFlag()

    88             {

    89             TBool flag(iFlag);

    90             iFlag = EFalse;

    91             return flag;

    92             }

    93     protected:

    94         TBool iFlag;

    95     };

    96 

    97 // ============================ MEMBER FUNCTIONS ==============================

    98 

    99 // ----------------------------------------------------------------------------

   100 // Constructor

   101 // ----------------------------------------------------------------------------

   102 //

   103 EXPORT_C CMPXDbManager::CMPXDbManager(

   104     RFs& aFs) :

   105     iFs(aFs)

   106     {

   107     MPX_FUNC("CMPXDbManager::CMPXDbManager");

   108     }

   109 

   110 // ----------------------------------------------------------------------------

   111 // Second phase constructor.

   112 // ----------------------------------------------------------------------------

   113 //

   114 EXPORT_C void CMPXDbManager::ConstructL(

   115     const TFileName& aDatabaseFile)

   116     {

   117     MPX_FUNC("CMPXDbManager::ConstructL");

   118     iDbFile = aDatabaseFile.AllocL();

   119     }

   120 

   121 // ----------------------------------------------------------------------------

   122 // Destructor

   123 // ----------------------------------------------------------------------------

   124 //

   125 EXPORT_C CMPXDbManager::~CMPXDbManager()

   126     {

   127     MPX_FUNC("CMPXDbManager::~CMPXDbManager");

   128 

   129     // Close the state array

   130     iPreparedStatements.Close();

   131 

   132     // Close and destroy all RSQLStatements

   133     TInt c( iStatements.Count() );

   134     for( TInt i=0; i<c; ++i )

   135         {

   136         iStatements[i]->Close();

   137         }

   138     iStatements.ResetAndDestroy();

   139 

   140     iTables.Close();

   141     CloseAllDatabases();

   142 

   143     delete iDbFile;

   144     }

   145 

   146 // ----------------------------------------------------------------------------

   147 // Checks if all databases have been initialized.

   148 // ----------------------------------------------------------------------------

   149 //

   150 EXPORT_C TBool CMPXDbManager::IsInitialized()

   151     {

   152     MPX_FUNC("CMPXDbManager::IsInitialized");

   153     return iInitialized;

   154     }

   155 

   156 // ----------------------------------------------------------------------------

   157 // Begins a transaction on all databases.

   158 // ----------------------------------------------------------------------------

   159 //

   160 EXPORT_C void CMPXDbManager::BeginL()

   161     {

   162     MPX_FUNC("CMPXDbManager::BeginL");

   163 

   164     ASSERT(iTransactionCount >= 0);

   165 

   166     if (++iTransactionCount == 1)

   167         {

   168         TInt err = iDatabase.Exec(KBeginTransaction);

   169         

   170         // transforms SQL error to KErrNotReady

   171         if( (err <= KSqlErrGeneral && err >= KSqlErrNotDb) || err == KSqlErrStmtExpired )

   172             {

   173             User::Leave(KErrNotReady);

   174             }

   175         else

   176             {

   177             User::LeaveIfError(err);

   178             }

   179         }

   180     }

   181 

   182 // ----------------------------------------------------------------------------

   183 // Commits a transaction on all databases.

   184 // ----------------------------------------------------------------------------

   185 //

   186 EXPORT_C void CMPXDbManager::CommitL()

   187     {

   188     MPX_FUNC("CMPXDbManager::CommitL");

   189 

   190     if(iTransactionCount > 0)

   191         {

   192         if (--iTransactionCount == 0)

   193             {

   194             TInt err = iDatabase.Exec(KCommitTransaction);

   195             

   196             // transforms SQL error to KErrNotReady

   197             if( (err <= KSqlErrGeneral && err >= KSqlErrNotDb) || err == KSqlErrStmtExpired )

   198                 {

   199                 User::Leave(KErrNotReady);

   200                 }

   201             else

   202                 {

   203                 User::LeaveIfError(err);

   204                 }

   205             }

   206         }

   207     }

   208 

   209 // ----------------------------------------------------------------------------

   210 // Rolls back a transaction on all databases.

   211 // ----------------------------------------------------------------------------

   212 //

   213 EXPORT_C void CMPXDbManager::RollbackL()

   214     {

   215     MPX_FUNC("CMPXDbManager::RollbackL");

   216 

   217     if(iTransactionCount > 0)

   218         {

   219         if (--iTransactionCount == 0)

   220             {

   221             TInt err = iDatabase.Exec(KRollbackTransaction);

   222             

   223             // transforms SQL error to KErrNotReady

   224             if( (err <= KSqlErrGeneral && err >= KSqlErrNotDb) || err == KSqlErrStmtExpired )

   225                 {

   226                 User::Leave(KErrNotReady);  

   227                 }

   228             else

   229                 {

   230                 User::LeaveIfError(err);

   231                 }

   232             }

   233     	}

   234     }

   235 

   236 // ----------------------------------------------------------------------------

   237 // Rolls back a transaction on all databases.

   238 // ----------------------------------------------------------------------------

   239 //

   240 EXPORT_C TBool CMPXDbManager::InTransaction()

   241     {

   242     MPX_FUNC("CMPXDbManager::InTransaction");

   243     return iDatabase.InTransaction();

   244     }

   245 

   246 // ----------------------------------------------------------------------------

   247 // Tries to create and open the databases on all specified drives.

   248 // ----------------------------------------------------------------------------

   249 //

   250 EXPORT_C void CMPXDbManager::InitDatabasesL(

   251     RArray<TInt> aDrives)

   252     {

   253     MPX_FUNC("CMPXDbManager::InitDatabasesL");

   254 

   255     CloseAllDatabases();

   256 

   257     TDriveUnit cdrive(KRootDrive());

   258 

   259     CreateDatabaseL(cdrive);

   260     OpenDatabaseL(cdrive);

   261 

   262     TInt count(aDrives.Count());

   263     for (TInt i = 0; i < count; ++i)

   264         {

   265         TDriveUnit drive(aDrives[i]);

   266         if ((drive != cdrive) && !IsRemoteDrive(static_cast<TDriveNumber>(aDrives[i])))

   267             {

   268             const TDesC& driveName = drive.Name();

   269 

   270             DatabaseHandle handle;

   271 

   272             handle.iDrive = aDrives[i];

   273             handle.iAliasname = HBufC::NewL(KAliasName().Length());

   274             handle.iAliasname->Des().Format(KAliasName, &driveName);

   275             handle.iOpen = EFalse;

   276 

   277             iDatabaseHandles.AppendL(handle);

   278 

   279             TVolumeInfo vol;

   280             if (iFs.Volume(vol, drive) == KErrNone)

   281                 {

   282                 CreateDatabaseL(drive);

   283                 AttachDatabaseL(drive);

   284                 }

   285             }

   286         }

   287 

   288     iInitialized = ETrue;

   289     }

   290 

   291 // ----------------------------------------------------------------------------

   292 // Opens a specified database.

   293 // ----------------------------------------------------------------------------

   294 //

   295 EXPORT_C void CMPXDbManager::OpenDatabaseL(

   296     TInt aDrive)

   297     {

   298     MPX_FUNC("CMPXDbManager::OpenDatabaseL");

   299 

   300     if (iInitialized == EFalse)

   301         {

   302         User::Leave(KErrNotReady);

   303         }

   304 

   305     TDriveUnit drive(aDrive);

   306     TDriveUnit cdrive(KRootDrive());

   307     TBool found(EFalse);

   308 

   309     if ((drive != cdrive) && !IsRemoteDrive(static_cast<TDriveNumber>(aDrive)))

   310         {

   311         TInt count(iDatabaseHandles.Count());

   312         for (TInt i = 0; i < count; ++i)

   313             {

   314             if (iDatabaseHandles[i].iDrive == aDrive)

   315                 {

   316                 if (!iDatabaseHandles[i].iOpen)

   317                     {

   318                     // make sure the database is created

   319 					CreateDatabaseL(drive);

   320 

   321 					// attach

   322                     AttachDatabaseL(drive);

   323                     }

   324 

   325                 found = ETrue;

   326                 break;

   327                 }

   328             }

   329         }

   330     if (!found)

   331         {

   332         User::Leave(KErrArgument);

   333         }

   334 

   335     // Close all prepared statements if a db is opened

   336     //

   337     ResetPreparedQueries();

   338     }

   339 

   340 // ----------------------------------------------------------------------------

   341 // Closes a specified database.

   342 // ----------------------------------------------------------------------------

   343 //

   344 EXPORT_C void CMPXDbManager::CloseDatabaseL(

   345     TInt aDrive)

   346     {

   347     MPX_FUNC("CMPXDbManager::CloseDatabaseL");

   348 

   349     if (iInitialized == EFalse)

   350         {

   351         User::Leave(KErrNotReady);

   352         }

   353 

   354     // Close all prepared statements if a db is closed

   355     //

   356     ResetPreparedQueries();

   357 

   358     TDriveUnit drive(aDrive);

   359     TDriveUnit cdrive(KRootDrive());

   360     TBool found(EFalse);

   361 

   362     if ((drive != cdrive) && !IsRemoteDrive(static_cast<TDriveNumber>(aDrive)))

   363         {

   364         TInt count(iDatabaseHandles.Count());

   365         for (TInt i = 0; i < count; ++i)

   366             {

   367             if (iDatabaseHandles[i].iDrive == aDrive)

   368                 {

   369                 if (iDatabaseHandles[i].iOpen)

   370                     {

   371                     DetachDatabaseL(drive);

   372                     }

   373 

   374                 found = ETrue;

   375                 break;

   376                 }

   377             }

   378         }

   379     if (!found)

   380         {

   381         User::Leave(KErrArgument);

   382         }

   383 

   384     }

   385 

   386 // ----------------------------------------------------------------------------

   387 // Closes all databases.

   388 // ----------------------------------------------------------------------------

   389 //

   390 EXPORT_C void CMPXDbManager::CloseAllDatabases()

   391     {

   392     MPX_FUNC("CMPXDbManager::CloseAllDatabases");

   393 

   394     if (iInitialized)

   395         {

   396         // Close all prepared statements if a db is closed

   397         //

   398         ResetPreparedQueries();

   399 

   400         TInt count(iDatabaseHandles.Count());

   401         for (TInt i = 0; i < count; ++i)

   402             {

   403             delete iDatabaseHandles[i].iAliasname;

   404             }

   405 

   406         iDatabaseHandles.Reset();

   407         iDatabase.Close();

   408         iInitialized = EFalse;

   409         }

   410     }

   411 

   412 // ----------------------------------------------------------------------------

   413 // Open all databases.

   414 // ----------------------------------------------------------------------------

   415 //

   416 EXPORT_C void CMPXDbManager::OpenAllDatabasesL()

   417     {

   418     MPX_FUNC("CMPXDbManager::OpenAllDatabasesL");

   419 

   420     if (!iInitialized)

   421         {

   422         TDriveUnit cdrive(KRootDrive());

   423         OpenDatabaseL(cdrive);

   424         }

   425 

   426     TInt count(iDatabaseHandles.Count());

   427     for (TInt i = 0; i < count; ++i)

   428         {

   429         TVolumeInfo vol;

   430         if (iFs.Volume(vol, iDatabaseHandles[i].iDrive) == KErrNone)

   431             {

   432             AttachDatabaseL(iDatabaseHandles[i].iDrive);

   433             }

   434         }

   435     iInitialized = ETrue;

   436 

   437     // Close all prepared statements if a db is closed

   438     //

   439     ResetPreparedQueries();

   440     }

   441 

   442 // ----------------------------------------------------------------------------

   443 // Checks if the database on a specified drive is open.

   444 // ----------------------------------------------------------------------------

   445 //

   446 EXPORT_C TBool CMPXDbManager::IsOpen(

   447     TInt aDrive) const

   448     {

   449     MPX_FUNC("CMPXDbManager::IsOpen");

   450 

   451     TDriveUnit drive(aDrive);

   452     TDriveUnit cdrive(KRootDrive());

   453 

   454     if (!iInitialized)

   455         {

   456         return EFalse;

   457         }

   458     else if (drive == cdrive)

   459         {

   460         return ETrue;

   461         }

   462     else

   463         {

   464         TInt count(iDatabaseHandles.Count());

   465         for (TInt i = 0; i < count; ++i)

   466             {

   467             if (iDatabaseHandles[i].iDrive == aDrive)

   468                 {

   469                 return iDatabaseHandles[i].iOpen;

   470                 }

   471             }

   472         }

   473 

   474     return EFalse;

   475     }

   476 

   477 // ----------------------------------------------------------------------------

   478 // Returns the number of currently open databases.

   479 // ----------------------------------------------------------------------------

   480 //

   481 EXPORT_C TInt CMPXDbManager::DatabaseCount() const

   482     {

   483     MPX_FUNC("CMPXDbManager::DatabaseCount");

   484 

   485     TInt openCount(0);

   486     if (iInitialized)

   487         {

   488         ++openCount;

   489 

   490         TInt count(iDatabaseHandles.Count());

   491         for (TInt i = 0; i < count; ++i)

   492             {

   493             if (iDatabaseHandles[i].iOpen)

   494                 {

   495                 ++openCount;

   496                 }

   497             }

   498         }

   499 

   500     return openCount;

   501     }

   502 

   503 // ----------------------------------------------------------------------------

   504 // Returns the drive corresponding to a given index.

   505 // ----------------------------------------------------------------------------

   506 //

   507 EXPORT_C TInt CMPXDbManager::DbDrive(

   508     TInt aIndex) const

   509     {

   510     MPX_FUNC("CMPXDbManager::DbDrive");

   511 

   512     ASSERT((aIndex >= 0) || (aIndex < iDatabaseHandles.Count()));

   513     return iDatabaseHandles[aIndex].iDrive;

   514     }

   515 

   516 // ----------------------------------------------------------------------------

   517 // Recreate a specified database.

   518 // ----------------------------------------------------------------------------

   519 //

   520 EXPORT_C void CMPXDbManager::RecreateDatabaseL(

   521     TInt aDrive)

   522     {

   523     MPX_FUNC("CMPXDbManager::RecreateDatabaseL");

   524 

   525     if (iInitialized == EFalse)

   526         {

   527         User::Leave(KErrNotReady);

   528         }

   529 

   530     TBool found(EFalse);

   531 

   532     if (aDrive == EDriveC)

   533         {

   534         found = ETrue;

   535         }

   536     else

   537         {

   538         TInt count(iDatabaseHandles.Count());

   539         for (TInt i = 0; i < count; ++i)

   540             {

   541             if ((iDatabaseHandles[i].iDrive == aDrive) && (iDatabaseHandles[i].iOpen))

   542                 {

   543                 found = ETrue;

   544                 break;

   545                 }

   546             }

   547         }

   548     if (found)

   549         {

   550         HBufC * filename = CreateFilenameL(aDrive);

   551         CleanupStack::PushL(filename);

   552 

   553         TRAPD(err, DoRecreateDatabaseL(filename));

   554         if(err < 0)

   555             {

   556             TDriveUnit drive_unit(aDrive);

   557 

   558             if(aDrive == EDriveC)

   559                 {

   560                 iDatabase.Close();

   561                 iInitialized = EFalse;

   562 

   563                 RSqlDatabase::Delete(*filename);

   564                 CreateDatabaseL(drive_unit);

   565 

   566                 User::LeaveIfError(iDatabase.Open(*filename));

   567                 iInitialized = ETrue;

   568                 }

   569             else

   570                 {

   571                 DetachDatabaseL(drive_unit);

   572 

   573                 RSqlDatabase::Delete(*filename);

   574                 CreateDatabaseL(drive_unit);

   575 

   576                 AttachDatabaseL(drive_unit);

   577                 }

   578             }

   579 

   580         CleanupStack::PopAndDestroy(filename);

   581         }

   582     else

   583         {

   584         User::Leave(KErrNotFound);

   585         }

   586     }

   587 

   588 // ----------------------------------------------------------------------------

   589 // Recreate all databases.

   590 // ----------------------------------------------------------------------------

   591 //

   592 EXPORT_C void CMPXDbManager::RecreateAllDatabasesL()

   593     {

   594     MPX_FUNC("CMPXDbManager::RecreateAllDatabasesL");

   595 

   596     if (iInitialized == EFalse)

   597         {

   598         User::Leave(KErrNotReady);

   599         }

   600 

   601     // Recreate on drive C

   602     RecreateDatabaseL(EDriveC);

   603 

   604     // Recreate all attached drives

   605     TInt count(iDatabaseHandles.Count());

   606     for (TInt i = 0; i < count; ++i)

   607         {

   608         if (iDatabaseHandles[i].iOpen)

   609             {

   610             RecreateDatabaseL(iDatabaseHandles[i].iDrive);

   611             }

   612         }

   613     }

   614 

   615 // ----------------------------------------------------------------------------

   616 // Returns current DB version

   617 // ----------------------------------------------------------------------------

   618 //

   619 EXPORT_C TVersion CMPXDbManager::Version() const

   620     {

   621     MPX_FUNC("CMPXDbManager::Version");

   622     return TVersion(KMPXDbVersion[0], KMPXDbVersion[1], KMPXDbVersion[2]);

   623     }

   624 

   625 // ----------------------------------------------------------------------------

   626 // Registes a table with the database

   627 // ----------------------------------------------------------------------------

   628 //

   629 EXPORT_C void CMPXDbManager::RegisterTableL(

   630     MMPXTable& aTable)

   631     {

   632     MPX_FUNC("CMPXDbManager::RegisterTableL");

   633     iTables.AppendL(&aTable);

   634     }

   635 

   636 // ----------------------------------------------------------------------------

   637 // Executes a select query with variable number of parameters

   638 // The query is executed on all available databases with a format like:

   639 //

   640 //      <query on database1> UNION ALL <query on database2> ...

   641 //

   642 // The query string passed in by the caller must have the ":dbname" prefix for all

   643 // the tables in the FROM clause. This will be replaced with the right alias for

   644 // attached databases or with no alias for the C database.

   645 //

   646 // In case the original query contains an ORDER BY clause, this will be extracted

   647 // and added at the end of the union query.

   648 //

   649 // Note: Running the union query seems to be similar in speed even if one of the

   650 // databases is empty and therefore no optimization was done for this case.

   651 // ----------------------------------------------------------------------------

   652 //

   653 EXPORT_C RSqlStatement CMPXDbManager::ExecuteSelectQueryL(

   654     TRefByValue<const TDesC> aFmt,

   655     ...)

   656     {

   657     MPX_FUNC("CMPXDatabase::ExecuteSelectQueryL");

   658 

   659     VA_LIST list;

   660     VA_START(list, aFmt);

   661 

   662     // Will reallocate

   663     HBufC* selectBuf = FormatQueryLC(aFmt, list);

   664     RSqlStatement statement = ExecuteSelectQueryOnAllDrivesL(selectBuf->Des());

   665     CleanupStack::PopAndDestroy(selectBuf);

   666 

   667     VA_END(list);

   668 

   669     return statement;

   670     }

   671 

   672 // ----------------------------------------------------------------------------

   673 // Executes a select query against a specified drive

   674 // ----------------------------------------------------------------------------

   675 //

   676 EXPORT_C RSqlStatement CMPXDbManager::ExecuteSelectQueryL(

   677     TInt aDrive,

   678     TRefByValue<const TDesC> aFmt,

   679     ...)

   680     {

   681     MPX_FUNC("CMPXDatabase::ExecuteSelectQueryL");

   682 

   683     VA_LIST list;

   684     VA_START(list, aFmt);

   685 

   686     // Will reallocate

   687     HBufC* selectBuf = FormatQueryLC(aFmt, list);

   688     RSqlStatement statement = ExecuteSelectQueryOnDriveL(aDrive, selectBuf->Des());

   689     CleanupStack::PopAndDestroy(selectBuf);

   690 

   691     VA_END(list);

   692 

   693     return statement;

   694     }

   695 

   696 // ----------------------------------------------------------------------------

   697 // CMPXDbManager::ExecuteSelectQueryL

   698 // ----------------------------------------------------------------------------

   699 //

   700 EXPORT_C RSqlStatement& CMPXDbManager::ExecuteSelectQueryL(

   701     TUint aStatementId,

   702     TInt aFirstValue,

   703     TInt aSecondValue,

   704     TRefByValue<const TDesC> aFmt,

   705     ...)

   706     {

   707     MPX_FUNC("CMPXDatabase::ExecuteOffsetSelectQueryL");

   708 

   709     // Prepare the Query first

   710     VA_LIST list;

   711     VA_START(list, aFmt);

   712     RSqlStatement& statement = PrepareQueryL( aStatementId, aFmt, list );

   713     VA_END(list);

   714 

   715     // Bind the Limit and Offset variables

   716     User::LeaveIfError(statement.BindInt(0, aFirstValue));

   717     User::LeaveIfError(statement.BindInt(1, aSecondValue));

   718 

   719     return statement;

   720     }

   721 

   722 // ----------------------------------------------------------------------------

   723 // CMPXDbManager::ExecuteSelectQueryL

   724 // ----------------------------------------------------------------------------

   725 //

   726 EXPORT_C RSqlStatement& CMPXDbManager::ExecuteSelectQueryL( TUint aStatementId,

   727                                                             const TDesC& aFirstValue,

   728                                                             TInt aSecondValue,

   729                                                             TRefByValue<const TDesC> aFmt, ...)

   730     {

   731     MPX_FUNC("CMPXDbManager::ExecuteMediaAscQueryL");

   732 

   733     // Prepare the Query first

   734     VA_LIST list;

   735     VA_START(list, aFmt);

   736     RSqlStatement& statement = PrepareQueryL( aStatementId, aFmt, list );

   737     VA_END(list);

   738 

   739     // bind the title and limit values

   740     User::LeaveIfError(statement.BindText(0, aFirstValue));

   741     User::LeaveIfError(statement.BindInt(1, aSecondValue));

   742 

   743     return statement;

   744     }

   745 

   746 // ----------------------------------------------------------------------------

   747 // Executes a query that does not return a record set (INSERT, UPDATE, DELETE,

   748 // CREATE, DROP, etc).

   749 //

   750 // If a valid drive is specified then the query is only executed only on

   751 // that drive. If KDbManagerAllDrives is specified then the query is executed

   752 // separately on each available drive.

   753 // ----------------------------------------------------------------------------

   754 //

   755 EXPORT_C void CMPXDbManager::ExecuteQueryL(

   756     TInt aDrive,

   757     TRefByValue<const TDesC> aFmt,

   758     ...)

   759     {

   760     MPX_FUNC("CMPXDatabase::ExecuteQueryL");

   761 

   762     // make sure there is enough space on all drives affected

   763     CheckDiskSpaceL(aDrive);

   764 

   765     VA_LIST list;

   766     VA_START(list, aFmt);

   767 

   768     HBufC* selectBuf = FormatQueryLC(aFmt, list);

   769     TPtr selectBufPtr = selectBuf->Des();

   770     TInt dbCount(iDatabaseHandles.Count());

   771 

   772     // a specified drive or all drives

   773     TInt loopCount = (aDrive == KDbManagerAllDrives) ? (dbCount + 1) : 1;

   774     TBool queryExecuted(EFalse); // flag to check if the query was executed at least once

   775     for (TInt j = 0; j < loopCount; ++j)

   776         {

   777         HBufC* query = HBufC::NewLC(selectBufPtr.Length() + KBufIncrement);

   778         TPtr queryPtr = query->Des();

   779         queryPtr.Copy(selectBufPtr);

   780         if (aDrive == EDriveC) // if C drive only

   781             {

   782             RemoveDriveAlias(queryPtr);

   783             }

   784         else // all drives or a particular drive other than C drive

   785             {

   786             if (aDrive == 0) // all drives

   787                 {

   788                 if (j == dbCount) // C drive

   789                     {

   790                     RemoveDriveAlias(queryPtr);

   791                     }

   792                 else //all other drives, except C drive

   793                     {

   794                     if (iDatabaseHandles[j].iOpen)

   795                         {

   796                         ReplaceDriveAlias(queryPtr, *(iDatabaseHandles[j].iAliasname));

   797                         }

   798                     }

   799                 }

   800             else //a particular drive, other than C drive

   801                 {

   802                 for (TInt i = 0; i < dbCount; ++i)

   803                     {

   804                     if (iDatabaseHandles[i].iOpen && iDatabaseHandles[i].iDrive == aDrive)

   805                         {

   806                         ReplaceDriveAlias(queryPtr, *(iDatabaseHandles[i].iAliasname));

   807                         break;

   808                         }

   809                     }

   810                 }

   811             }

   812         TInt dbnamePos = queryPtr.Find(KDBNameToken);// check if the query was created correctly

   813         if (dbnamePos == KErrNotFound)

   814             {

   815             // log the query

   816             TPtrC ptr(query->Left(KMaxLogQuery));

   817             MPX_DEBUG2("Query: %S", &ptr);

   818 

   819             User::LeaveIfError(ExecuteSqlStatement(iDatabase, queryPtr));

   820             queryExecuted = ETrue;

   821             }

   822         CleanupStack::PopAndDestroy(query);

   823         }   //for (TInt j = 0; j < loopCount; ++j)

   824     CleanupStack::PopAndDestroy(selectBuf);

   825     VA_END(list);

   826     if (!queryExecuted && aDrive !=   0)

   827         {

   828         // the requested drive(s) is not open

   829         User::Leave(KErrNotFound);

   830         }

   831     }

   832 

   833 // ----------------------------------------------------------------------------

   834 // CMPXDbManager::FormatQueryLC

   835 // ----------------------------------------------------------------------------

   836 //

   837 HBufC* CMPXDbManager::FormatQueryLC(

   838     TRefByValue<const TDesC> aFmt,

   839     VA_LIST aList)

   840     {

   841     MPX_FUNC("CMPXDatabase::FormatQueryLC");

   842 

   843     TOverflowHandle overflow;

   844 

   845     HBufC* selectBuf = HBufC::NewLC(TDesC(aFmt).Length());//will reallocate

   846     selectBuf->Des().AppendFormatList(aFmt, aList, &overflow);

   847     while (overflow.GetOverflowFlag())

   848         {

   849         TInt len = selectBuf->Des().MaxLength() + KBufIncrement;

   850         CleanupStack::PopAndDestroy(selectBuf);

   851         selectBuf = HBufC::NewLC(len);

   852         selectBuf->Des().AppendFormatList(aFmt, aList, &overflow);

   853         }

   854 

   855     return selectBuf;

   856     }

   857 

   858 // ----------------------------------------------------------------------------

   859 // Executes a select query against a specified drive

   860 // ----------------------------------------------------------------------------

   861 //

   862 EXPORT_C RSqlStatement CMPXDbManager::ExecuteSelectQueryOnAllDrivesL(

   863     TInt aDrive,

   864     TRefByValue<const TDesC> aFmt,

   865     ...)

   866     {

   867     MPX_FUNC("CMPXDatabase::ExecuteSelectQueryL");

   868 

   869     VA_LIST list;

   870     VA_START(list, aFmt);

   871 

   872     // Will reallocate

   873     HBufC* selectBuf = FormatQueryLC(aFmt, list);

   874     RSqlStatement statement = ExecuteSelectQueryOnAllDrivesL(aDrive, selectBuf->Des());

   875     CleanupStack::PopAndDestroy(selectBuf);

   876 

   877     VA_END(list);

   878 

   879     return statement;

   880     }

   881 

   882 // ----------------------------------------------------------------------------

   883 // CMPXDbManager::ExecuteSelectQueryOnAllDrivesL

   884 // ----------------------------------------------------------------------------

   885 //

   886 RSqlStatement CMPXDbManager::ExecuteSelectQueryOnAllDrivesL(

   887     TPtr aQuery)

   888     {

   889     MPX_FUNC("CMPXDatabase::ExecuteSelectQueryOnAllDrivesL");

   890 

   891     TInt dbCount = iDatabaseHandles.Count();

   892     HBufC* query = HBufC::NewLC(aQuery.Length() * (dbCount + 1) +

   893         KUnionAllToken().Length() * dbCount);

   894     TPtr queryPtr = query->Des();

   895     HBufC* selectOutBuf = NULL;

   896     TInt enclosed = aQuery.Mid(1, aQuery.Length() - 1).Find(KSelectToken);

   897     if (enclosed != KErrNotFound)

   898         {

   899         enclosed++;//to compensate the indent

   900         selectOutBuf = HBufC::NewLC(aQuery.Length() * (dbCount + 1) +

   901             KUnionAllToken().Length() * dbCount);

   902         selectOutBuf->Des().Copy(aQuery.Left(enclosed));

   903         selectOutBuf->Des().Append(aQuery.Right(1));//the closing bracket

   904         aQuery.Delete(0, enclosed);

   905         aQuery.Delete(aQuery.Length() - 1, 1);

   906         }

   907 

   908     HBufC* orderBuf = NULL;

   909     TInt orderPos = aQuery.Find(KOrderByToken);

   910     if (orderPos != KErrNotFound)

   911         {

   912         orderBuf = aQuery.Right(aQuery.Length() - orderPos).AllocL();

   913         aQuery.Delete(orderPos, aQuery.Length() - orderPos);

   914         }

   915     queryPtr.Append(aQuery);// for cdrive

   916     RemoveDriveAlias(queryPtr);

   917     for (TInt i = 0; i < dbCount; ++i)//for other drives

   918         {

   919         if (iDatabaseHandles[i].iOpen)

   920             {

   921             queryPtr.Append(KUnionAllToken);

   922             queryPtr.Append(aQuery);

   923             ReplaceDriveAlias(queryPtr, *(iDatabaseHandles[i].iAliasname));

   924             }

   925         }

   926     if (orderBuf)

   927         {

   928         queryPtr.Append(orderBuf->Des());

   929         }

   930     delete orderBuf;

   931     if (enclosed != KErrNotFound)

   932         {

   933         selectOutBuf->Des().Insert(enclosed, query->Des());

   934         queryPtr.Copy(selectOutBuf->Des());

   935         CleanupStack::PopAndDestroy(selectOutBuf);

   936         }

   937 

   938     // Log the query string before execution

   939     TPtrC ptr(query->Left(KMaxLogQuery));

   940     MPX_DEBUG2("Query: %S", &ptr);

   941 

   942     // Return a temporary statement and not a member variable.

   943     // This ensures that a copy is done and a second embedded query can be

   944     // executed while the first result set is processed.

   945     RSqlStatement statement;

   946     User::LeaveIfError(statement.Prepare(iDatabase, queryPtr));

   947     CleanupStack::PopAndDestroy(query);

   948 

   949     return statement;

   950     }

   951 

   952 // ----------------------------------------------------------------------------

   953 // CMPXDbManager::ExecuteSelectQueryOnAllDrivesL

   954 // ----------------------------------------------------------------------------

   955 //

   956 RSqlStatement CMPXDbManager::ExecuteSelectQueryOnAllDrivesL( TInt aDrive,

   957     TPtr aQuery)

   958     {

   959     MPX_FUNC("CMPXDatabase::ExecuteSelectQueryOnAllDrivesL");

   960 

   961     TInt dbCount = iDatabaseHandles.Count();

   962     HBufC* query = HBufC::NewLC(aQuery.Length() * (dbCount + 1) +

   963         KUnionAllToken().Length() * dbCount);

   964     TPtr queryPtr = query->Des();

   965     HBufC* selectOutBuf = NULL;

   966     TInt enclosed = aQuery.Mid(1, aQuery.Length() - 1).Find(KSelectToken);

   967     if (enclosed != KErrNotFound)

   968         {

   969         enclosed++;//to compensate the indent

   970         selectOutBuf = HBufC::NewLC(aQuery.Length() * (dbCount + 1) +

   971             KUnionAllToken().Length() * dbCount);

   972         selectOutBuf->Des().Copy(aQuery.Left(enclosed));

   973         selectOutBuf->Des().Append(aQuery.Right(1));//the closing bracket

   974         aQuery.Delete(0, enclosed);

   975         aQuery.Delete(aQuery.Length() - 1, 1);

   976         }

   977 

   978     HBufC* orderBuf = NULL;

   979     TInt orderPos = aQuery.Find(KOrderByToken);

   980     if (orderPos != KErrNotFound)

   981         {

   982         orderBuf = aQuery.Right(aQuery.Length() - orderPos).AllocL();

   983         aQuery.Delete(orderPos, aQuery.Length() - orderPos);

   984         }

   985     

   986     //remove KPlDBNameToken

   987     if ( aDrive == EDriveC )//if playlist on c drive

   988     	{

   989     	RemoveDriveAlias(aQuery,KPlDBNameToken);

   990     	}

   991     else

   992     	{//for other drives

   993 	    for (TInt i = 0; i < dbCount; ++i)

   994 	        {

   995 	        if (iDatabaseHandles[i].iOpen && (iDatabaseHandles[i].iDrive == aDrive))

   996 	            {

   997 	            ReplaceDriveAlias(aQuery, *(iDatabaseHandles[i].iAliasname),

   998 	            		KPlDBNameToken);

   999 	            break;

  1000 	            }

  1001 	        }

  1002     	}

  1003     

  1004     queryPtr.Append(aQuery);// for cdrive

  1005     RemoveDriveAlias(queryPtr);

  1006     for (TInt i = 0; i < dbCount; ++i)//for other drives

  1007         {

  1008         if (iDatabaseHandles[i].iOpen)

  1009             {

  1010             queryPtr.Append(KUnionAllToken);

  1011             queryPtr.Append(aQuery);

  1012             ReplaceDriveAlias(queryPtr, *(iDatabaseHandles[i].iAliasname));

  1013             }

  1014         }

  1015    

  1016     if (orderBuf)

  1017         {

  1018         queryPtr.Append(orderBuf->Des());

  1019         }

  1020     delete orderBuf;

  1021     if (enclosed != KErrNotFound)

  1022         {

  1023         selectOutBuf->Des().Insert(enclosed, query->Des());

  1024         queryPtr.Copy(selectOutBuf->Des());

  1025         CleanupStack::PopAndDestroy(selectOutBuf);

  1026         }

  1027 

  1028     // Log the query string before execution

  1029     TPtrC ptr(query->Left(KMaxLogQuery));

  1030     MPX_DEBUG2("Query: %S", &ptr);

  1031 

  1032     // Return a temporary statement and not a member variable.

  1033     // This ensures that a copy is done and a second embedded query can be

  1034     // executed while the first result set is processed.

  1035     RSqlStatement statement;

  1036     TInt err(statement.Prepare(iDatabase, queryPtr));

  1037     User::LeaveIfError(err);

  1038     CleanupStack::PopAndDestroy(query);

  1039 

  1040     return statement;

  1041     }

  1042 

  1043 // ----------------------------------------------------------------------------

  1044 // CMPXDbManager::ExecuteSelectQueryOnDriveLryLC

  1045 // ----------------------------------------------------------------------------

  1046 //

  1047 RSqlStatement CMPXDbManager::ExecuteSelectQueryOnDriveL(

  1048     TInt aDrive,

  1049     TPtr aQuery)

  1050     {

  1051     MPX_FUNC("CMPXDatabase::ExecuteSelectQueryOnDriveL");

  1052 

  1053     RSqlStatement statement;

  1054     if (KDbManagerAllDrives == aDrive)

  1055         {

  1056         statement = ExecuteSelectQueryOnAllDrivesL(aQuery);

  1057         }

  1058     else

  1059         {

  1060         TInt dbCount(iDatabaseHandles.Count());

  1061 

  1062         // flag to check if the query was executed at least once

  1063         TBool queryExecuted = EFalse;

  1064 

  1065         HBufC* query = HBufC::NewLC(aQuery.Length() + KBufIncrement);

  1066         TPtr queryPtr = query->Des();

  1067         queryPtr.Copy(aQuery);

  1068         if (aDrive == EDriveC) //if C drive

  1069             {

  1070             RemoveDriveAlias(queryPtr);

  1071             }

  1072         else // drive other than C drive

  1073             {

  1074             for (TInt i = 0; i < dbCount; ++i)

  1075                 {

  1076                 if (iDatabaseHandles[i].iOpen && (iDatabaseHandles[i].iDrive == aDrive))

  1077                     {

  1078                     ReplaceDriveAlias(queryPtr, *(iDatabaseHandles[i].iAliasname));

  1079                     break;

  1080                     }

  1081                 }

  1082             }

  1083 

  1084         TInt dbnamePos = queryPtr.Find(KDBNameToken);// check if the query was created correctly

  1085         if (dbnamePos == KErrNotFound)

  1086             {

  1087             // Log the query string before execution

  1088             TPtrC ptr(query->Left(KMaxLogQuery));

  1089             MPX_DEBUG2("Query: %S", &ptr);

  1090 

  1091             User::LeaveIfError(statement.Prepare(iDatabase, queryPtr));

  1092             queryExecuted = ETrue;

  1093             }

  1094         CleanupStack::PopAndDestroy(query);

  1095 

  1096         if (!queryExecuted)

  1097             {

  1098             // the requested drive(s) is not open

  1099             User::Leave(KErrNotFound);

  1100             }

  1101         }

  1102 

  1103     return statement;

  1104     }

  1105 

  1106 // ----------------------------------------------------------------------------

  1107 // Prepare a query for execution on all open database. This query's lifetime

  1108 // is owned by the dbmanager

  1109 // ----------------------------------------------------------------------------

  1110 //

  1111 RSqlStatement& CMPXDbManager::PrepareQueryL( TUint aStatementId,

  1112                                              TRefByValue<const TDesC> aFmt,

  1113                                              VA_LIST aList )

  1114     {

  1115     // Try to find the query first if it has been created

  1116     TInt index(KErrNotFound);

  1117     TInt c(iPreparedStatements.Count());

  1118 

  1119     for( TInt i=0; i<c; ++i )

  1120         {

  1121         if( iPreparedStatements[i].iId == aStatementId )

  1122             {

  1123             index = i;

  1124             break;

  1125             }

  1126         }

  1127 

  1128     // If the index isn't found we create a new query statement

  1129     //

  1130     if( index == KErrNotFound )

  1131         {

  1132         RSqlStatement* newStatement = new(ELeave) RSqlStatement();

  1133         CleanupStack::PushL(newStatement);

  1134