/*

* 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:  Base class for all table classes.

*

*/

// INCLUDE FILES

#include <mpxlog.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include "mpxdbcommonstd.h"

#include "mpxdbcommonutil.h"

#include "mpxdbmanager.h"

#include "mpxdbtable.h"

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

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

// Constructor

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

//

EXPORT_C CMPXDbTable::CMPXDbTable(

    CMPXDbManager& aDbManager) :

    iDbManager(aDbManager)

    {

    MPX_FUNC("CMPXDbTable::CMPXDbTable");

    }

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

// Second phase constructor.

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

//

EXPORT_C void CMPXDbTable::BaseConstructL()

    {

    MPX_FUNC("CMPXDbTable::BaseConstructL");

    iDbManager.RegisterTableL(*this);

    }

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

// Destructor

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

//

EXPORT_C CMPXDbTable::~CMPXDbTable()

    {

    MPX_FUNC("CMPXDbTable::~CMPXDbTable");

    }

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

// CMPXDbTable::UpdateMediaL default implementation

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

//

EXPORT_C void CMPXDbTable::UpdateMediaL(

    RSqlStatement& /* aRecord */,

    const TArray<TMPXAttribute>& /* aAttrs */,

    CMPXMedia& /* aMedia */)

    {

    // do nothing

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery,

    TInt aValue)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

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

    query->Des().Format(aQuery, aValue);

    ExecuteMediaQueryL(aAttrs, aMediaArray, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery,

    const TDesC& aValue)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

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

    query->Des().Format(aQuery, &aValue);

    ExecuteMediaQueryL(aAttrs, aMediaArray, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery,

    TInt aValue1,

    TInt aValue2)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

    HBufC* query = HBufC::NewLC(aQuery.Length() + 2 * KMCIntegerLen);

    query->Des().Format(aQuery, aValue1, aValue2);

    ExecuteMediaQueryL(aAttrs, aMediaArray, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery,

    const TDesC& aValue1,

    TInt aValue2)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

    HBufC* query = HBufC::NewLC(aQuery.Length() + aValue1.Length() + KMCIntegerLen);

    query->Des().Format(aQuery, &aValue1, aValue2);

    ExecuteMediaQueryL(aAttrs, aMediaArray, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery,

    const TDesC& aValue1,

    TInt aValue2,

    const TDesC& aValue3,

    TInt aValue4)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

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

                                aValue1.Length() +

                                aValue3.Length() +

                                2*KMCIntegerLen);

    query->Des().Format(aQuery, &aValue1, aValue2, &aValue3, aValue4);

    ExecuteMediaQueryL(aAttrs, aMediaArray, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aQuery));

    CleanupClosePushL(recordset);

    TInt pPath(0);

    if (aMediaArray.Count())

        {

        CMPXMedia* pMedia = aMediaArray[0];

        if (pMedia->IsSupported(KMPXMediaGeneralValue))

            { // Query excuted by OpenL

            pPath = pMedia->ValueTObjectL<TInt>(KMPXMediaGeneralValue);

            MPX_ASSERT(pPath);

            }

        }

    TInt err(KErrNone);

    RArray<TMPXItemId> ids;

    CleanupClosePushL(ids);

    while ((err = recordset.Next()) == KSqlAtRow)

        {

        CMPXMedia* media = CMPXMedia::NewL();

        CleanupStack::PushL(media);

        UpdateMediaL(recordset, aAttrs, *media);

        if (media->IsSupported(KMPXMediaGeneralId) && pPath)

            {

            ids.AppendL(media->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));

            }

        aMediaArray.AppendL(*media);

        CleanupStack::PopAndDestroy(media);

        }

    // Append ids to the returned path

    if (pPath)

        {

        ((CMPXCollectionPath*)pPath)->AppendL(ids.Array());

        }

    CleanupStack::PopAndDestroy(&ids);

    CleanupStack::PopAndDestroy(&recordset);

    if (err!= KSqlAtEnd)

        {

        User::Leave(KErrCorrupt);

        }

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

	TInt aDrive,

	const TArray<TMPXAttribute>& aAttrs,

	CMPXMediaArray& aMediaArray,

	const TDesC& aQuery,

	TInt aPlaylistId)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

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

    query->Des().Format(aQuery, aPlaylistId);

    ExecuteMediaQueryOnDriveL(aDrive, aAttrs, aMediaArray, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteMediaQueryOnDriveL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryOnDriveL(

	TInt aDrive,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryOnAllDrivesL(aDrive,aQuery));

    CleanupClosePushL(recordset);

    TInt pPath(0);

    if (aMediaArray.Count())

        {

        CMPXMedia* pMedia = aMediaArray[0];

        if (pMedia->IsSupported(KMPXMediaGeneralValue))

            { // Query excuted by OpenL

            pPath = pMedia->ValueTObjectL<TInt>(KMPXMediaGeneralValue);

            MPX_ASSERT(pPath);

            }

        }

    TInt err(KErrNone);

    RArray<TMPXItemId> ids;

    CleanupClosePushL(ids);

    while ((err = recordset.Next()) == KSqlAtRow)

        {

        CMPXMedia* media = CMPXMedia::NewL();

        CleanupStack::PushL(media);

        UpdateMediaL(recordset, aAttrs, *media);

        if (media->IsSupported(KMPXMediaGeneralId) && pPath)

            {

            ids.AppendL(media->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));

            }

        aMediaArray.AppendL(*media);

        CleanupStack::PopAndDestroy(media);

        }

    // Append ids to the returned path

    if (pPath)

        {

        ((CMPXCollectionPath*)pPath)->AppendL(ids.Array());

        }

    CleanupStack::PopAndDestroy(&ids);

    CleanupStack::PopAndDestroy(&recordset);

    if (err!= KSqlAtEnd)

        {

        User::Leave(KErrCorrupt);

        }

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TBool aAsc,

    const TDesC& aQuery)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aQuery));

    CleanupClosePushL(recordset);

    TInt err(KErrNone);

    while ((err = recordset.Next()) == KSqlAtRow)

        {

        CMPXMedia* media = CMPXMedia::NewL();

        CleanupStack::PushL(media);

        UpdateMediaL(recordset, aAttrs, *media);

        if (aAsc != EFalse)

            {

            aMediaArray.AppendL(*media);

            }

        else

            {

            aMediaArray.InsertL(*media, 0);

            }

        CleanupStack::PopAndDestroy(media);

        }

    CleanupStack::PopAndDestroy(&recordset);

    if (err!= KSqlAtEnd)

        {

        User::Leave(KErrCorrupt);

        }

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia,

    const TDesC& aQuery)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aQuery));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::Leave(KErrNotFound);

        }

    UpdateMediaL(recordset, aAttrs, aMedia);

    CleanupStack::PopAndDestroy(&recordset);

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia,

    const TDesC& aQuery,

    TInt aValue)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

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

    query->Des().Format(aQuery, aValue);

    ExecuteMediaQueryL(aAttrs, aMedia, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteMediaQueryL

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

//

EXPORT_C void CMPXDbTable::ExecuteMediaQueryL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray,

    const TDesC& aQuery,

    const TDesC& aValue1,

    const TDesC& aValue2)

    {

    MPX_FUNC("CMPXDbTable::ExecuteMediaQueryL");

    HBufC* query = HBufC::NewLC(aQuery.Length() + aValue1.Length() + aValue2.Length());

    query->Des().Format(aQuery, &aValue1, &aValue2);

    ExecuteMediaQueryL(aAttrs, aMediaArray, *query);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbTable::ExecuteIntQueryL

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

//

EXPORT_C TUint32 CMPXDbTable::ExecuteIntQueryL(

    const TDesC& aQuery)

    {

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aQuery));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::Leave(KErrNotFound);

        }

    TUint32 value(recordset.ColumnInt64(KMPXTableDefaultIndex));

    CleanupStack::PopAndDestroy(&recordset);

    return value;

    }

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

// CMPXDbTable::ExecuteIntQueryL

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

//

EXPORT_C TUint32 CMPXDbTable::ExecuteIntQueryL(

    const TDesC& aQuery,

    TUint32 aValue)

    {

    MPX_FUNC("CMPXDbTable::ExecuteIntQueryL");

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

    query->Des().Format(aQuery, aValue);

    TUint32 ret(ExecuteIntQueryL(*query));

    CleanupStack::PopAndDestroy(query);

    return ret;

    }

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

// CMPXDbTable::ExecuteIntQueryL

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

//

EXPORT_C TUint32 CMPXDbTable::ExecuteIntQueryL(

    const TDesC& aQuery,

    const TDesC& aValue1,

    TUint32 aValue2)

    {

    MPX_FUNC("CMPXDbTable::ExecuteIntQueryL");

    // replace single quotes

    // reserve double the value length for single quote duplicates

    HBufC* value1 = HBufC::NewLC(aValue1.Length() * 2);

    TPtr value1Ptr(value1->Des());

    MPXDbCommonUtil::FindAndReplaceSingleQuote(aValue1, value1Ptr);

    // construct the query

    HBufC* query = HBufC::NewLC(aQuery.Length() + value1Ptr.Length() + KMCIntegerLen);

    query->Des().Format(aQuery, value1, aValue2);

    // execute the query

    TUint32 ret(ExecuteIntQueryL(*query));

    CleanupStack::PopAndDestroy(query);

    CleanupStack::PopAndDestroy(value1);

    return ret;

    }

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

// CMPXDbTable::ExecuteIntQueryL

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

//

EXPORT_C TUint32 CMPXDbTable::ExecuteIntQueryL(

    const TDesC& aQuery,

    const TDesC& aValue)

    {

    MPX_FUNC("CMPXDbTable::ExecuteIntQueryL");

    // replace single quotes

    HBufC* value = HBufC::NewLC(aValue.Length() * 2);

    TPtr valuePtr(value->Des());

    MPXDbCommonUtil::FindAndReplaceSingleQuote(aValue, valuePtr);

    // construct the query

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

    query->Des().Format(aQuery, value);

    // execute the query

    TUint32 ret(ExecuteIntQueryL(*query));

    CleanupStack::PopAndDestroy(query);

    CleanupStack::PopAndDestroy(value);

    return ret;

    }

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

// CMPXDbTable::ExecuteIntQueryL

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

//

EXPORT_C TUint32 CMPXDbTable::ExecuteIntQueryL(

    const TDesC& aQuery,

    TUint32 aValue1,

    TUint32 aValue2)

    {

    MPX_FUNC("CMPXDbTable::ExecuteIntQueryL");

    HBufC* query = HBufC::NewLC(aQuery.Length() + 2 * KMCIntegerLen);

    query->Des().Format(aQuery, aValue1, aValue2);

    TUint32 ret(ExecuteIntQueryL(*query));

    CleanupStack::PopAndDestroy(query);

    return ret;

    }

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

// CMPXDbTable::ExecuteIntQueryL

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

//

EXPORT_C TUint32 CMPXDbTable::ExecuteIntQueryL(TInt aDriveID,const TDesC& aQuery)

    {