/*

* Copyright (c) 2007 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:  This class is responsible for managing all database access

*                databases.

*

*/

// INCLUDE FILES

#include <sqldb.h>

#include <badesca.h>

#include <f32file.h>

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

//#ifdef __WINSCW__    

//#include <sqlrowsetutil.h>

//#endif

#include <sysutil.h>

#include <mpxlog.h>

#include "mpxdbcommondef.h"

#include "mpxtable.h"

#include "mpxdbmanager.h"

// CONSTANTS

// Version of   Database

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

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

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

_LIT(KRootDrive, "C:");

_LIT(KAliasName, "%1SDrive");

_LIT(KBeginTransaction, "BEGIN TRANSACTION");

_LIT(KCommitTransaction, "COMMIT TRANSACTION");

_LIT(KRollbackTransaction, "ROLLBACK TRANSACTION");

_LIT(KOrderByToken, "ORDER BY");

_LIT(KDBNameToken, ":dbname");

_LIT(KPlDBNameToken, ":pldbname");

_LIT(KUnionAllToken, " UNION ALL ");

_LIT(KSelectToken, "SELECT");

//for database deletion

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

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

#ifdef _DEBUG

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

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

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

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

_LIT(KNameColumn, "name");

#endif

const TInt KMaxLogQuery = 248;

const TInt KBufIncrement = 10;

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

class TOverflowHandle :

    public TDesOverflow

    {

    public:

        TOverflowHandle() :

            iFlag(EFalse)

            {

            }

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

            {

            iFlag = ETrue;

            return;

            }

        TBool GetOverflowFlag()

            {

            TBool flag(iFlag);

            iFlag = EFalse;

            return flag;

            }

    protected:

        TBool iFlag;

    };

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

// ----------------------------------------------------------------------------

// Constructor

// ----------------------------------------------------------------------------

//

EXPORT_C CMPXDbManager::CMPXDbManager(

    RFs& aFs) :

    iFs(aFs)

    {

    MPX_FUNC("CMPXDbManager::CMPXDbManager");

    }

// ----------------------------------------------------------------------------

// Second phase constructor.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::ConstructL(

    const TFileName& aDatabaseFile)

    {

    MPX_FUNC("CMPXDbManager::ConstructL");

    iDbFile = aDatabaseFile.AllocL();

    }

// ----------------------------------------------------------------------------

// Destructor

// ----------------------------------------------------------------------------

//

EXPORT_C CMPXDbManager::~CMPXDbManager()

    {

    MPX_FUNC("CMPXDbManager::~CMPXDbManager");

    // Close the state array

    iPreparedStatements.Close();

    // Close and destroy all RSQLStatements

    TInt c( iStatements.Count() );

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

        {

        iStatements[i]->Close();

        }

    iStatements.ResetAndDestroy();

    iTables.Close();

    CloseAllDatabases();

    delete iDbFile;

    }

// ----------------------------------------------------------------------------

// Checks if all databases have been initialized.

// ----------------------------------------------------------------------------

//

EXPORT_C TBool CMPXDbManager::IsInitialized()

    {

    MPX_FUNC("CMPXDbManager::IsInitialized");

    return iInitialized;

    }

// ----------------------------------------------------------------------------

// Begins a transaction on all databases.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::BeginL()

    {

    MPX_FUNC("CMPXDbManager::BeginL");

    ASSERT(iTransactionCount >= 0);

    if (++iTransactionCount == 1)

        {

        TInt err = iDatabase.Exec(KBeginTransaction);

        // transforms SQL error to KErrNotReady

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

            {

            User::Leave(KErrNotReady);

            }

        else

            {

            User::LeaveIfError(err);

            }

        }

    }

// ----------------------------------------------------------------------------

// Commits a transaction on all databases.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::CommitL()

    {

    MPX_FUNC("CMPXDbManager::CommitL");

    if(iTransactionCount > 0)

        {

        if (--iTransactionCount == 0)

            {

            TInt err = iDatabase.Exec(KCommitTransaction);

            // transforms SQL error to KErrNotReady

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

                {

                User::Leave(KErrNotReady);

                }

            else

                {

                User::LeaveIfError(err);

                }

            }

        }

    }

// ----------------------------------------------------------------------------

// Rolls back a transaction on all databases.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::RollbackL()

    {

    MPX_FUNC("CMPXDbManager::RollbackL");

    if(iTransactionCount > 0)

        {

        if (--iTransactionCount == 0)

            {

            TInt err = iDatabase.Exec(KRollbackTransaction);

            // transforms SQL error to KErrNotReady

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

                {

                User::Leave(KErrNotReady);  

                }

            else

                {

                User::LeaveIfError(err);

                }

            }

    	}

    }

// ----------------------------------------------------------------------------

// Rolls back a transaction on all databases.

// ----------------------------------------------------------------------------

//

EXPORT_C TBool CMPXDbManager::InTransaction()

    {

    MPX_FUNC("CMPXDbManager::InTransaction");

    return iDatabase.InTransaction();

    }

// ----------------------------------------------------------------------------

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

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::InitDatabasesL(

    RArray<TInt> aDrives)

    {

    MPX_FUNC("CMPXDbManager::InitDatabasesL");

    CloseAllDatabases();

    TDriveUnit cdrive(KRootDrive());

    CreateDatabaseL(cdrive);

    OpenDatabaseL(cdrive);

    TInt count(aDrives.Count());

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

        {

        TDriveUnit drive(aDrives[i]);

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

            {

            const TDesC& driveName = drive.Name();

            DatabaseHandle handle;

            handle.iDrive = aDrives[i];

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

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

            handle.iOpen = EFalse;

            iDatabaseHandles.AppendL(handle);

            TVolumeInfo vol;

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

                {

                CreateDatabaseL(drive);

                AttachDatabaseL(drive);

                }

            }

        }

    iInitialized = ETrue;

    }

// ----------------------------------------------------------------------------

// Opens a specified database.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::OpenDatabaseL(

    TInt aDrive)

    {

    MPX_FUNC("CMPXDbManager::OpenDatabaseL");

    if (iInitialized == EFalse)

        {

        User::Leave(KErrNotReady);

        }

    TDriveUnit drive(aDrive);

    TDriveUnit cdrive(KRootDrive());

    TBool found(EFalse);

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

        {

        TInt count(iDatabaseHandles.Count());

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

            {

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

                {

                if (!iDatabaseHandles[i].iOpen)

                    {

                    // make sure the database is created

					CreateDatabaseL(drive);

					// attach

                    AttachDatabaseL(drive);

                    }

                found = ETrue;

                break;

                }

            }

        }

    if (!found)

        {

        User::Leave(KErrArgument);

        }

    // Close all prepared statements if a db is opened

    //

    ResetPreparedQueries();

    }

// ----------------------------------------------------------------------------

// Closes a specified database.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::CloseDatabaseL(

    TInt aDrive)

    {

    MPX_FUNC("CMPXDbManager::CloseDatabaseL");

    if (iInitialized == EFalse)

        {

        User::Leave(KErrNotReady);

        }

    // Close all prepared statements if a db is closed

    //

    ResetPreparedQueries();

    TDriveUnit drive(aDrive);

    TDriveUnit cdrive(KRootDrive());

    TBool found(EFalse);

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

        {

        TInt count(iDatabaseHandles.Count());

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

            {

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

                {

                if (iDatabaseHandles[i].iOpen)

                    {

                    DetachDatabaseL(drive);

                    }

                found = ETrue;

                break;

                }

            }

        }

    if (!found)

        {

        User::Leave(KErrArgument);

        }

    }

// ----------------------------------------------------------------------------

// Closes all databases.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::CloseAllDatabases()

    {

    MPX_FUNC("CMPXDbManager::CloseAllDatabases");

    if (iInitialized)

        {

        // Close all prepared statements if a db is closed

        //

        ResetPreparedQueries();

        TInt count(iDatabaseHandles.Count());

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

            {

            delete iDatabaseHandles[i].iAliasname;

            }

        iDatabaseHandles.Reset();

        iDatabase.Close();

        iInitialized = EFalse;

        }

    }

// ----------------------------------------------------------------------------

// Open all databases.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::OpenAllDatabasesL()

    {

    MPX_FUNC("CMPXDbManager::OpenAllDatabasesL");

    if (!iInitialized)

        {

        TDriveUnit cdrive(KRootDrive());

        OpenDatabaseL(cdrive);

        }

    TInt count(iDatabaseHandles.Count());

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

        {

        TVolumeInfo vol;

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

            {

            AttachDatabaseL(iDatabaseHandles[i].iDrive);

            }

        }

    iInitialized = ETrue;

    // Close all prepared statements if a db is closed

    //

    ResetPreparedQueries();

    }

// ----------------------------------------------------------------------------

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

// ----------------------------------------------------------------------------

//

EXPORT_C TBool CMPXDbManager::IsOpen(

    TInt aDrive) const

    {

    MPX_FUNC("CMPXDbManager::IsOpen");

    TDriveUnit drive(aDrive);

    TDriveUnit cdrive(KRootDrive());

    if (!iInitialized)

        {

        return EFalse;

        }

    else if (drive == cdrive)

        {

        return ETrue;

        }

    else

        {

        TInt count(iDatabaseHandles.Count());

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

            {

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

                {

                return iDatabaseHandles[i].iOpen;

                }

            }

        }

    return EFalse;

    }

// ----------------------------------------------------------------------------

// Returns the number of currently open databases.

// ----------------------------------------------------------------------------

//

EXPORT_C TInt CMPXDbManager::DatabaseCount() const

    {

    MPX_FUNC("CMPXDbManager::DatabaseCount");

    TInt openCount(0);

    if (iInitialized)

        {

        ++openCount;

        TInt count(iDatabaseHandles.Count());

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

            {

            if (iDatabaseHandles[i].iOpen)

                {

                ++openCount;

                }

            }

        }

    return openCount;

    }

// ----------------------------------------------------------------------------

// Returns the drive corresponding to a given index.

// ----------------------------------------------------------------------------

//

EXPORT_C TInt CMPXDbManager::DbDrive(

    TInt aIndex) const

    {

    MPX_FUNC("CMPXDbManager::DbDrive");

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

    return iDatabaseHandles[aIndex].iDrive;

    }

// ----------------------------------------------------------------------------

// Recreate a specified database.

// ----------------------------------------------------------------------------

//

EXPORT_C void CMPXDbManager::RecreateDatabaseL(

    TInt aDrive)

    {

    MPX_FUNC("CMPXDbManager::RecreateDatabaseL");

    if (iInitialized == EFalse)

        {

        User::Leave(KErrNotReady);

        }