/*

* Copyright (c) 2008 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:      SQLite Connection class

*

*/

#include <utf.h>

#include "cmsqlclausedef.h"

#include "cmsqlresolutionpropertyitem.h"

#include "cmsqlaudioitem.h"

#include "cmsqlvideoitem.h"

#include "cmsqlimageitem.h"

#include "cmfilllistitem.h"

#include "cmfillrule.h"

#include "cmsqlpropertycollector.h"

#include "cmsqlpropertycontainer.h"

#include "cmsqlconnection.h"

#include "msdebug.h"

_LIT8( KCmSqlPragmaCacheSize, 

    "PRAGMA cache_size=1024;PRAGMA page_size=4096;"

    );                   

#ifdef _DEBUG

_LIT( KCmSqlWrapper, "SqlWrapper");

#endif // _DEBUG

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

// CCmSqlConnection::NewL

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

//

CCmSqlConnection* CCmSqlConnection::NewL()

    {

    TRACE(Print(_L("[SQL wrapper]\t CCmSqlConnection::NewL()")));

    CCmSqlConnection* self = CCmSqlConnection::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmSqlConnection::NewLC

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

//    

CCmSqlConnection* CCmSqlConnection::NewLC()

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::NewLC"));

    CCmSqlConnection* self = new ( ELeave ) CCmSqlConnection();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;  

    }    

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

// CCmSqlConnection::~CCmSqlConnection

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

//

CCmSqlConnection::~CCmSqlConnection()

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::~CCmSqlConnection"));

    CloseDb();

    if( iAsyncDbHandler )

        {

        iAsyncDbHandler->Cancel();

        delete iAsyncDbHandler;       

        }

    delete iCountQuery;

    }

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

// CCmSqlConnection::OpenDb

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

//

TInt CCmSqlConnection::OpenDb( const TDesC& aDb )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::OpenDb"));

    TInt err( iDatabase.Open( aDb, NULL ) );

    if( err == KErrNone )

        {

        err = iDatabase.Exec( KCmSqlPragmaCacheSize );        

        if ( err != KErrNone )

            {

            TRACE(Print(_L("[SQL wrapper]\t KCmSqlPragmaCacheSize\

             error %d"), err));        

            }        

        }

    return err;    

    }    

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

// CCmSqlConnection::CloseDb

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

//

void CCmSqlConnection::CloseDb()

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::CloseDb"));

    iDatabase.Close();

    }

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

// CCmSqlConnection::CreateDbFile

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

//

TInt CCmSqlConnection::CreateDbFile( const TDesC& aDb )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::CreateDbFile"));

    return iDatabase.Create( aDb );

    }

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

// CCmSqlConnection::Validate

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

//

TBool CCmSqlConnection::Validate()

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::Validate"));

    TBool retval = EFalse;

    // In the test period it is useful that the database is re-created

    // every run. because most of the test cases are automatic and require

    // a known initial state.

    TInt ret( KErrNone );

    TInt err = iStatement.Prepare( iDatabase, 

        KCmSqlValidateTableExistence );

    // Loop only one row in results

    if( err )

        {

        ret = KErrGeneral;

        }

    else

        {

        err = iStatement.Next();    

        if ( err != KSqlAtRow )  

            {

            ret = KErrGeneral;       

            }

        iStatement.Reset();

        iStatement.Close();          

        }    

    if ( ret == KErrNone ) 

        {

        retval = ETrue;

        }

    return retval;

    }

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

// CCmSqlConnection::ExecuteL

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

//

void CCmSqlConnection::ExecuteL( const TDesC8& aCommand )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::ExecuteL"));

    TInt err( iDatabase.Exec( aCommand ) );

    if ( KErrNone > err  )

        {

#ifdef _DEBUG        

        TPtrC errorMsg( iDatabase.LastErrorMessage() );

        TRACE(Print(_L("[SQL wrapper]\t errorMsg: %S"), &errorMsg ));

#endif        

        User::Leave( err );    

        }    

    }

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

// CCmSqlConnection::CancelAsyncOperation

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

//

void CCmSqlConnection::CancelAsyncOperation()

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::CancelAsyncOperation"));

    if( ECmSqlBaseItemGet == iMode || ECmSqlFillItemGet == iMode ||

        ECmSqlPropertyValueGet == iMode )

        {

        iStatement.Reset();

        iStatement.Close();        

        }

    iMode = ECmSqlIdle;        

    if ( iAsyncDbHandler->IsActive() )

        {

        User::RequestComplete( iStatus, KErrCancel );

        iAsyncDbHandler->Cancel();

        TRACE(Print(_L("[SQL wrapper]\t Canceled...")));

        }

    }

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

// CCmSqlConnection::SetMsId

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

//

void CCmSqlConnection::SetMsId( TUint aId )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::SetMsId"));

    iMsId = aId;

    }

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

// CCmSqlConnection::SetQuota

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

//

void CCmSqlConnection::SetQuota( TInt64 aQuota )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::SetQuota"));

    iQuota = aQuota;

    }

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

// CCmSqlConnection::AsyncBatchAdd

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

//

void CCmSqlConnection::AsyncBatchAdd( 

    RPointerArray<CCmSqlGenericItem>& aItems, TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::AsyncBatchAdd"));

    __ASSERT_DEBUG( iAsyncDbHandler,\

        User::Panic( KCmSqlWrapper, KErrCorrupt ));

    iStatus = &aStatus;        

    if( !iAsyncDbHandler->IsActive() )

        {    

        iIndex = 0;

        iGenericItems = &aItems;

        iMode = ECmSqlGenericItemAdd;  

        iAsyncDbHandler->Start( TCallBack( BatchAdd, this ) );

        }

    else

        {

        User::RequestComplete( iStatus, KErrNotReady );

        }            

    }

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

// ACCmSqlConnection::syncBatchAddPropertyItems 

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

//

void CCmSqlConnection::AsyncBatchAddPropertyItems( 

    RPointerArray<CCmSqlPropertyItem>& aItems, TCmMetadataField aField,

    TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::AsyncBatchAddPropertyItems"));

    __ASSERT_DEBUG( iAsyncDbHandler,\

        User::Panic( KCmSqlWrapper, KErrCorrupt ));

    iStatus = &aStatus;        

    if( !iAsyncDbHandler->IsActive() )

        {    

        iIndex = 0;

        iField = aField;

        iPropertyItems = &aItems;

        iMode = ECmSqlPropertyItemAdd;

        iAsyncDbHandler->Start( TCallBack( BatchAdd, this ) );

        }

    else

        {

        User::RequestComplete( iStatus, KErrNotReady );

        } 

    }

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

// CCmSqlConnection::SyncAddPropertyItemL 

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

//

void CCmSqlConnection::SyncAddPropertyItemL( 

    CCmSqlPropertyItem& aItem, TCmMetadataField aField )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::SyncAddPropertyItemL"));

    iIndex = 0;

    iField = aField;

    RPointerArray<CCmSqlPropertyItem> temp;

    CleanupClosePushL( temp );

    temp.AppendL( &aItem );

    iPropertyItems = &temp;

    AddPropertyItemL();

    FormatRowCountQueryL( aField );

    // Autoincremented row index is used as a item id

    aItem.SetId( RowCountL() );

    delete iCountQuery;

    iCountQuery = NULL;

    temp.Reset();

    CleanupStack::PopAndDestroy( &temp );

    }

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

// CCmSqlConnection::AsyncBatchDelete

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

//    

void CCmSqlConnection::AsyncBatchDelete( 

    RPointerArray<CCmSqlBaseItem>& aItems, 

    TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::AsyncBatchDelete"));

    __ASSERT_DEBUG( iAsyncDbHandler,\

        User::Panic( KCmSqlWrapper, KErrCorrupt ));

    iStatus = &aStatus;        

    if( !iAsyncDbHandler->IsActive() )

        {

        iBaseItems = &aItems;

        iIndex = 0;    

        iAsyncDbHandler->Start( TCallBack( BatchDelete, this ) );

        }        

    else

        {

        User::RequestComplete( iStatus, KErrNotReady );

        } 

    }

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

// CCmSqlConnection::AsyncMetadataDelete

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

//

void CCmSqlConnection::AsyncMetadataDelete( RArray<TInt>& aMsIds, 

    TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::AsyncMetadataDelete"));

    __ASSERT_DEBUG( iAsyncDbHandler,\

        User::Panic( KCmSqlWrapper, KErrCorrupt ));

    iStatus = &aStatus;         

    if( !iAsyncDbHandler->IsActive() )

        {

        iMsIds = &aMsIds;

        iIndex = 0;

        iMode = ECmSqlDeletingMetadata;    

        iAsyncDbHandler->Start( TCallBack( BatchDelete, this ) );

        }        

    else

        {

        User::RequestComplete( iStatus, KErrNotReady );

        } 

    }

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

// CCmSqlConnection::DeleteOldestMediaItemsL

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

//

void CCmSqlConnection::DeleteOldestMediaItemsL( TCmMediaType aType, 

    TInt64 aCount )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::DeleteOldestMediaItemsL"));

    TInt err = iStatement.Prepare( iDatabase, KCmSqlSelectLimitHarvestDate );

    TInt64 timestamp( KErrNone );

    User::LeaveIfError( err );

    iStatement.BindInt( 0, aType );

    iStatement.BindInt64( 1, aCount );

    while( KSqlAtRow == iStatement.Next() )

        {

        timestamp = iStatement.ColumnInt64( 0 );

        }

    iStatement.Reset();

    iStatement.Close();    

    if( timestamp )

        {

        err = iStatement.Prepare( iDatabase, KCmSqlDeleteOldestMediaItems );

        User::LeaveIfError( err );

        iStatement.BindInt64( 0, timestamp );

        iStatement.BindInt( 1, aType );

        iStatement.Exec();

        iStatement.Reset();

        iStatement.Close();  

        }

    }

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

// CCmSqlConnection::DeleteUnusedPropertys()

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

//

void CCmSqlConnection::DeleteUnusedPropertys( )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::DeleteUnusedPropertys"));

    iDatabase.Exec( KCmSqlDeleteUnusedAlbums );

    iDatabase.Exec( KCmSqlDeleteUnusedArtists );

    iDatabase.Exec( KCmSqlDeleteUnusedGenres );

    iDatabase.Exec( KCmSqlDeleteUnusedUpnpclasses );

    iDatabase.Exec( KCmSqlDeleteUnusedUpnpProfileIds );  

    }

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

// CCmSqlConnection::GetItemsL

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

// 

void CCmSqlConnection::GetItemsL( RPointerArray<CCmSqlBaseItem>& aItems,

    TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::GetItemsL"));

    __ASSERT_DEBUG( iAsyncDbHandler,\

        User::Panic( KCmSqlWrapper, KErrCorrupt ));

    iStatus = &aStatus;         

    if( !iAsyncDbHandler->IsActive() )

        {    

        iBaseItems = &aItems;

        iMode = ECmSqlBaseItemGet;

        iIndex = 0;

        TInt err = iStatement.Prepare( iDatabase, 

            KCmSqlSelectGenericItem );

        User::LeaveIfError( err );

        iStatement.BindInt( 0, iMsId );   

        iAsyncDbHandler->Start( TCallBack( BatchGetL, this ) );

        }        

    else

        {

        User::RequestComplete( iStatus, KErrNotReady );

        } 

    }

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

// CCmSqlConnection::GetFillItemsL

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

// 

void CCmSqlConnection::GetFillItemsL( RPointerArray<CCmFillListItem>& aItems,

    TDesC8& aClause, CCmFillRule& aRule, TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::GetFillItemsL"));

    __ASSERT_DEBUG( iAsyncDbHandler,\

        User::Panic( KCmSqlWrapper, KErrCorrupt ));  

    iStatus = &aStatus;    

    if( !iAsyncDbHandler->IsActive() )

        {    

        iList = &aRule;

        iIndex = 0;

        iListSize = 0;

        iListMaxSize = 0;

        iFillItems = &aItems;

        iMode = ECmSqlFillItemGet;

        if( EMbits == iList->LimitType() )

            {

            // Converting list max size to bytes

            iListMaxSize = ( iList->Amount() * 1000000 );

            }

        // Unlimited lists are limited to mmc quota    

        else if( EUnlimited == iList->LimitType() )

            {

            iListMaxSize = iQuota;

            }

        TInt err = iStatement.Prepare( iDatabase, aClause );

        User::LeaveIfError( err );  

        iAsyncDbHandler->Start( TCallBack( BatchGetL, this ) );

        }

    else

        {

        User::RequestComplete( iStatus, KErrNotReady );

        } 

    }

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

// CCmSqlConnection::GetPropertyValuesL

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

//    

void CCmSqlConnection::GetPropertyValuesL( 

    RPointerArray<CCmSqlPropertyItem>& aItems, TDesC8& aClause,

    TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::GetPropertyValuesL"));

    __ASSERT_DEBUG( iAsyncDbHandler,\

        User::Panic( KCmSqlWrapper, KErrCorrupt ));

    iStatus = &aStatus;        

    if( !iAsyncDbHandler->IsActive() )

        {

        iPropertyItems = &aItems;

        iIndex = 0;

        iMode = ECmSqlPropertyValueGet;

        TInt err = iStatement.Prepare( iDatabase, aClause );

        User::LeaveIfError( err );

        iAsyncDbHandler->Start( TCallBack( BatchGetL, this ) );        

        }        

    else

        {

        User::RequestComplete( iStatus, KErrNotReady );

        }  

    }

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

// CCmSqlConnection::GetFilteredPropertyValuesL

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

//    

void CCmSqlConnection::GetFilteredPropertyValuesL( 

    CCmSqlPropertyCollector& aPropertys, const TDesC8& aClause, 

    TRequestStatus& aStatus )

    {

    LOG(_L("[SQL Wrapper]\t CCmSqlConnection::GetFilteredPropertyValuesL"));