/*
* Copyright (c) 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: Implements the base class for the various lookup tables
*
*/
// INCLUDE FILES
#include <sqldb.h>
#include <mpxmedia.h>
#include <mpxmediaarray.h>
#include <mpxmediageneraldefs.h>
#include <mpxlog.h>
#include "mpxdbcommonutil.h"
#include "mpxdbcommondef.h"
#include "mpxdbmanager.h"
#include "mpxdbutil.h"
#include "mpxpodcastcollectiondbdef.h"
#include "mpxpodcastcollectiondbstd.h"
#include "mpxpodcastdbpluginqueries.h"
#include "mpxdbcategory.h"
// CONSTANTS
// maximum number of table name entries per query
const TInt KMaxTableNameCount = 2;
// ============================ MEMBER FUNCTIONS ==============================
// ----------------------------------------------------------------------------
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CMPXDbCategory* CMPXDbCategory::NewL(
CMPXDbManager& aDbManager,
TMPXGeneralCategory aCategory)
{
MPX_FUNC("CMPXDbCategory::NewL");
CMPXDbCategory* self = CMPXDbCategory::NewLC(aDbManager, aCategory);
CleanupStack::Pop(self);
return self;
}
// ----------------------------------------------------------------------------
// Two-phased constructor, leave object in cleanup stack.
// ----------------------------------------------------------------------------
//
CMPXDbCategory* CMPXDbCategory::NewLC(
CMPXDbManager& aDbManager,
TMPXGeneralCategory aCategory)
{
MPX_FUNC("CMPXDbCategory::NewLC");
CMPXDbCategory* self = new (ELeave) CMPXDbCategory(aDbManager, aCategory);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
// ----------------------------------------------------------------------------
// Destructor.
// ----------------------------------------------------------------------------
//
CMPXDbCategory::~CMPXDbCategory()
{
MPX_FUNC("CMPXDbCategory::~CMPXDbCategory");
delete iTableName;
}
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
//
CMPXDbCategory::CMPXDbCategory(
CMPXDbManager& aDbManager,
TMPXGeneralCategory aCategory) :
CMPXDbTable(aDbManager),
iCategory(aCategory)
{
MPX_FUNC("CMPXDbCategory::CMPXDbCategory");
}
// ----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::ConstructL()
{
MPX_FUNC("CMPXDbCategory::ConstructL");
BaseConstructL();
iTableName = MPXDbUtil::TableNameForCategoryL(iCategory).AllocL();
}
// ----------------------------------------------------------------------------
// Add a row containing the name to the lookup table
// If the name already exists in the table, increment the count
// ----------------------------------------------------------------------------
//
TUint32 CMPXDbCategory::AddItemL(
const TDesC& aName,
TInt aDriveId,
TBool& aNewRecord,
TBool aCaseSensitive)
{
MPX_FUNC("CMPXDbCategory::AddItemL");
// try to find the item first
TUint32 rowId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), iCategory, aName, aCaseSensitive));
aNewRecord = !CategoryItemExistsL(aDriveId, rowId);
if (aNewRecord)
{
// insert new
HBufC* query = PreProcessStringLC(KQueryCategoryInsert);
HBufC* name = MPXDbCommonUtil::ProcessSingleQuotesLC(aName);
iDbManager.ExecuteQueryL(aDriveId, *query, rowId, name, 1);
CleanupStack::PopAndDestroy(name);
CleanupStack::PopAndDestroy(query);
}
else
{
// increment the number of episodes for the category
HBufC* query = PreProcessStringLC(KQueryCategoryIncrementEpisodeCount);
iDbManager.ExecuteQueryL(aDriveId, *query, rowId);
CleanupStack::PopAndDestroy(query);
}
return rowId;
}
// ----------------------------------------------------------------------------
// Get the name of the row matching the given ID
// ----------------------------------------------------------------------------
//
HBufC* CMPXDbCategory::GetNameL(
TUint32 aId)
{
MPX_FUNC("CMPXDbCategory::GetNameL");
RSqlStatement recordset(GetCategoryRecordL(aId));
CleanupClosePushL(recordset);
if (recordset.Next() != KSqlAtRow)
{
User::LeaveIfError(KErrNotFound);
}
HBufC* name = MPXDbCommonUtil::GetColumnTextL(recordset, ECategoryName).AllocL();
CleanupStack::PopAndDestroy(&recordset);
return name;
}
// ----------------------------------------------------------------------------
// Count the total number of items
// ----------------------------------------------------------------------------
//
TInt CMPXDbCategory::CountL()
{
MPX_FUNC("CMPXDbCategory::CountL");
HBufC* query = PreProcessStringLC(KQueryCategoryCount);
TInt count(ExecuteSumQueryL(*query));
CleanupStack::PopAndDestroy(query);
return count;
}
// ----------------------------------------------------------------------------
// Find record(s) that match(es) the selection criteria
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::FindAllL(
const CMPXMedia& aCriteria,
const TArray<TMPXAttribute>& aAttrs,
CMPXMediaArray& aMediaArray)
{
MPX_FUNC("CMPXDbCollection::FindAllL");
// process the requested attributes
// the UniqueId is always requested
TBool titleRequested(EFalse);
TBool counterRequested(EFalse);
TInt viewingColumnCount(aAttrs.Count());
for (TInt i = 0; i < viewingColumnCount; ++i)
{
TInt contentId(aAttrs[i].ContentId());
if (contentId == KMPXMediaIdGeneral)
{
TUint attributeId(aAttrs[i].AttributeId());
if (attributeId & EMPXMediaGeneralTitle)
{
titleRequested = ETrue;
}
if (attributeId & EMPXMediaGeneralCount)
{
counterRequested = ETrue;
}
}
}
TMPXGeneralType type = aCriteria.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);
const TArray<TMPXAttribute> criteria = aCriteria.Attributes();
TInt criteriaCount(criteria.Count());
// process the criteria and construct the criteria string
CDesCArrayFlat* criteriaArray = new (ELeave) CDesCArrayFlat(criteriaCount + 1);
CleanupStack::PushL(criteriaArray);
TBool criteriaCounterSet(EFalse);
TInt criteriaCounter(0);
for (TInt i = 0; i < criteriaCount; ++i)
{
const TMPXAttribute& criterion = criteria[i];
if ((type == EMPXItem) && (criterion == KMPXMediaGeneralId))
{
TUint32 itemId = (aCriteria.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2;
if (MPX_ITEM_CATEGORY(itemId) != iCategory)
{
User::Leave(KErrNotSupported);
}
HBufC* critStr = PreProcessStringLC(KCriterionCategoryUniqueId);
MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, *critStr, itemId);
CleanupStack::PopAndDestroy(critStr);
}
else if (criterion == KMPXMediaGeneralTitle)
{
HBufC* critStr = PreProcessStringLC(KCriterionCategoryName);
HBufC* title = MPXDbCommonUtil::ProcessPatternCharsLC(
aCriteria.ValueText(KMPXMediaGeneralTitle));
MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, *critStr, *title);
CleanupStack::PopAndDestroy(2, critStr); // title & Str
}
else if (criterion == KMPXMediaGeneralCount)
{
criteriaCounterSet = ETrue;
criteriaCounter = aCriteria.ValueTObjectL<TInt>(KMPXMediaGeneralCount);
}
else
{
// ignore attribute
}
}
// construct criteria string
HBufC* criteriaStr = MPXDbCommonUtil::StringFromArrayLC(*criteriaArray, KMCAndKeyword);
// either get all items or items filtered based on criteria
HBufC* query = PreProcessStringLC(criteriaStr->Length() ?
KQueryCategoryItems() : KQueryCategoryAll());
RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(*query, criteriaStr));
CleanupStack::PopAndDestroy(query);
CleanupStack::PopAndDestroy(criteriaStr);
CleanupStack::PopAndDestroy(criteriaArray);
CleanupClosePushL(recordset);
// It is possible to get multiple records with the same ID in the case where the same category
// name is present on more than one drive (the unique ID is constructed from the name alone
// for categories). The records have to be processed manually as the songs count cannot be
// summed in the query.
//
// Unknown artist/album/genre/composer is stored in the database as NULL (name field). This
// ensures the unknown artist/album/genre/composer to be the 1st found record if it exists.
// This will save time in searching for the unknown record among the results and avoid
// performing descriptor comparison.
// If the 1st record is the unknown artist/album/genre/composer, it won't be appended to the
// array until all other records have been put in the array.
//
// NOTE: putting unknown artist/album/genre/composer to the end of the array only takes place
// when title field is requested. normal sorting algorithm occurs if title isn't requested,
// i.e. client requests for Id only. The Id of the unknown record will be the 1st item in
// the array if it exists.
//
TBool firstGroup(ETrue);
CMPXMedia* unknownMedia(NULL);
CMPXMedia* media(NULL);
TUint32 prevId(0);
TUint32 currId(0);
TUint32 accumulatedCounter(0);
TInt err(KErrNone);
while ((err = recordset.Next()) == KSqlAtRow)
{
// Setup basic info - with first record of a group
currId = recordset.ColumnInt64(ECategoryUniqueId);
if (currId != prevId)
{
// first or new set of records
if (media)
{
// valid previous record set
if (criteriaCounterSet && (criteriaCounter != accumulatedCounter))
{
// the counter criterion does not match
// discard the media and unknownMedia
CleanupStack::PopAndDestroy(media);
if (firstGroup && unknownMedia)
{
unknownMedia = NULL;
}
}
else
{
if (!firstGroup || !unknownMedia)
{
// append the media to the array
if (counterRequested)
{
media->SetTObjectValueL<TInt>(KMPXMediaGeneralCount, accumulatedCounter);
}
aMediaArray.AppendL(*media);
CleanupStack::PopAndDestroy(media);
}
firstGroup = EFalse;
}
}
// start a new media object
media = CMPXMedia::NewL();
CleanupStack::PushL(media);
media->SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem);
media->SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, iCategory);
media->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, currId);
if (titleRequested)
{
TPtrC name = MPXDbCommonUtil::GetColumnTextL(recordset, ECategoryName);
if (firstGroup && (name.Length() == 0))
{
unknownMedia = media;
}
media->SetTextValueL(KMPXMediaGeneralTitle, name);
}
accumulatedCounter = 0;
prevId = currId;
}
accumulatedCounter += GetEpisodeCountL(KDbManagerAllDrives, currId);
}
// process last record
if (media)
{
// valid previous record set
if (criteriaCounterSet && (criteriaCounter != accumulatedCounter))
{
// the counter criterion does not match
// discard the media and unknownMedia
CleanupStack::PopAndDestroy(media);
if (firstGroup && unknownMedia)
{
unknownMedia = NULL;
}
}
else
{
if (!firstGroup || !unknownMedia)
{
// append the media to the array
if (counterRequested)
{
media->SetTObjectValueL<TInt>(KMPXMediaGeneralCount, accumulatedCounter);
}
aMediaArray.AppendL(*media);
CleanupStack::PopAndDestroy(media);
}
}
}
if (unknownMedia)
{
aMediaArray.AppendL(*unknownMedia);
CleanupStack::PopAndDestroy(unknownMedia); // the first media that contains unknown title
}
CleanupStack::PopAndDestroy(&recordset);
if (err != KSqlAtEnd)
{
User::LeaveIfError(err);
}
}
// ----------------------------------------------------------------------------
// Decrement the number of episodes in the row. If the count gets to 0, remove the row.
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::DecrementEpisodesForCategoryL(
const TUint32 aId,
TInt aDriveId,
CMPXMessageArray* aItemChangedMessages)
{
MPX_FUNC("CMPXDbCategory::DecrementEpisodesForCategoryL");
// if just one episode uses this category, use <= just in case
if (GetEpisodeCountL(aDriveId, aId) <= 1)
{
// delete the category
DeleteCategoryL(aId, aDriveId);
if (aItemChangedMessages)
{
// add the item changed message
MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aId, EMPXItemDeleted,
iCategory, KDBPluginUid);
}
}
else
{
// decrement the number of episodes for the category
HBufC* query = PreProcessStringLC(KQueryCategoryDecrementEpisodeCount);
iDbManager.ExecuteQueryL(aDriveId, *query, aId);
CleanupStack::PopAndDestroy(query);
}
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::DeleteCategoryL
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::DeleteCategoryL(
TUint32 aId,
TInt aDriveId)
{
MPX_FUNC("CMPXDbCategory::DeleteCategoryL");
HBufC* query = PreProcessStringLC(KQueryCategoryDelete);
iDbManager.ExecuteQueryL(aDriveId, *query, aId);
CleanupStack::PopAndDestroy(query);
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::GetCategoryItemL
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::GetCategoryItemL(
TUint32 aId,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aMedia)
{
MPX_FUNC("CMPXDbCategory::GetCategoryItemL");
HBufC* query = PreProcessStringLC(KQueryCategoryItem);
ExecuteMediaQueryL(aAttrs, aMedia, *query, aId);
CleanupStack::PopAndDestroy(query);
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::GetCategoryItemsL
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::GetCategoryItemsL(
const TArray<TMPXAttribute>& aAttrs,
CMPXMediaArray& aMediaArray)
{
MPX_FUNC("CMPXDbCategory::GetCategoryItemsL");
// have to run one query to get all items as opposed to individual queries
// because of the sorting
// construct the unique ID criteria string
// (UniqueId = %u OR UniqueId = %u ...)
TInt itemCount(aMediaArray.Count());
HBufC* criteria = HBufC::NewLC((2 * KCriterionCategoryUniqueId().Length() +
KMCIntegerLen + KMCOrKeyword().Length() + 2) * itemCount);
TPtr ptr(criteria->Des());
ptr.Append(KMCOpenBracket);
for (TInt index = 0; index < itemCount; ++index)
{
CMPXMedia* media = aMediaArray[index];
HBufC* critStr = PreProcessStringLC(KCriterionCategoryUniqueId);
HBufC* criterion = MPXDbCommonUtil::SqlCriterionLC(*critStr,
media->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
ptr.Append(*criterion);
CleanupStack::PopAndDestroy(criterion);
CleanupStack::PopAndDestroy(critStr);
if (index < itemCount - 1)
{
ptr.Append(KMCOrKeyword);
}
}
ptr.Append(KMCCloseBracket);
// the array has to be reset as the items have to be returned in a different sort order
aMediaArray.Reset();
HBufC* query = PreProcessStringLC(KQueryCategoryItems);
RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(*query, criteria));
CleanupStack::PopAndDestroy(query);
CleanupStack::PopAndDestroy(criteria);
CleanupClosePushL(recordset);
ProcessRecordsetL(aAttrs, recordset, aMediaArray);
CleanupStack::PopAndDestroy(&recordset);
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::GetAllCategoryItemsL
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::GetAllCategoryItemsL(
const TArray<TMPXAttribute>& aAttrs,
CMPXMediaArray& aMediaArray)
{
MPX_FUNC("CMPXDbCategory::GetAllCategoryItemsL");
HBufC* query = PreProcessStringLC(KQueryCategoryAll);
RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(*query));
CleanupStack::PopAndDestroy(query);
CleanupClosePushL(recordset);
ProcessRecordsetL(aAttrs, recordset, aMediaArray);
CleanupStack::PopAndDestroy(&recordset);
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::CategoryItemExistsL
// The category records must be in the same database as the corresponding
// Podcast record, otherwise when adding a duplicate of a song on a
// different drive this method will return true and the category record won't
// be created.
// ----------------------------------------------------------------------------
//
TBool CMPXDbCategory::CategoryItemExistsL(
TInt aDriveId,
TUint32 aId)
{
MPX_FUNC("CMPXDbCategory::CategoryItemExistsL");
HBufC* query = PreProcessStringLC(KQueryCategoryItem);
RSqlStatement recordset(
iDbManager.ExecuteSelectQueryL(aDriveId, *query, aId));
TBool exists(recordset.Next() == KSqlAtRow);
recordset.Close();
CleanupStack::PopAndDestroy(query);
return exists;
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::GetSongsCountL
// ----------------------------------------------------------------------------
//
TInt CMPXDbCategory::GetEpisodeCountL(
TInt aDriveId,
TUint32 aId)
{
MPX_FUNC("CMPXDbCategory::GetEpisodeCountL");
HBufC* query = PreProcessStringLC(KQueryCategoryGetEpisodeCount);
RSqlStatement recordset(
iDbManager.ExecuteSelectQueryL(aDriveId, *query, aId));
CleanupClosePushL(recordset);
if (recordset.Next() != KSqlAtRow)
{
User::Leave(KErrNotFound);
}
TInt ret = recordset.ColumnInt(KMPXTableDefaultIndex);
CleanupStack::PopAndDestroy(&recordset);
CleanupStack::PopAndDestroy(query);
return ret;
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::UpdateMediaL
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::UpdateMediaL(
RSqlStatement& aRecord,
const TArray<TMPXAttribute>& aAttrs,
CMPXMedia& aMedia)
{
MPX_FUNC("CMPXDbCategory::UpdateMediaL");
TInt attrCount(aAttrs.Count());
for (TInt i = 0; i < attrCount; ++i)
{
TInt contentId(aAttrs[i].ContentId());
TUint attributeId(aAttrs[i].AttributeId());
if (contentId == KMPXMediaIdGeneral)
{
if (attributeId & EMPXMediaGeneralId)
{
aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId,
aRecord.ColumnInt64(ECategoryUniqueId));
}
if (attributeId & EMPXMediaGeneralTitle)
{
aMedia.SetTextValueL(KMPXMediaGeneralTitle,
MPXDbCommonUtil::GetColumnTextL(aRecord, ECategoryName));
}
if (attributeId & EMPXMediaGeneralCount)
{
aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralCount,
GetEpisodeCountL(KDbManagerAllDrives,
aRecord.ColumnInt64(ECategoryUniqueId)));
}
} // end if contentId == KMPXMediaIdGeneral
} // end for
aMedia.SetTObjectValueL(KMPXMediaGeneralType, EMPXItem);
aMedia.SetTObjectValueL(KMPXMediaGeneralCategory, iCategory);
// Fix for EXAL-79ZC9M set the right Type and Cat for each item
if (iCategory == EMPXAlbum)
{
aMedia.SetTObjectValueL(KMPXMediaPodcastType, EMPXPodcastGroup);
aMedia.SetTObjectValueL(KMPXMediaPodcastCategoryGroup, EMPXTitle);
}
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::GetCategoryRecordL
// ----------------------------------------------------------------------------
//
RSqlStatement CMPXDbCategory::GetCategoryRecordL(
TUint32 aId)
{
MPX_FUNC("CMPXDbCategory::GetCategoryRecordL");
HBufC* query = PreProcessStringLC(KQueryCategoryItem);
RSqlStatement statement(iDbManager.ExecuteSelectQueryL(*query, aId));
CleanupStack::PopAndDestroy(query);
return statement;
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::PreProcessStringLC
// ----------------------------------------------------------------------------
//
HBufC* CMPXDbCategory::PreProcessStringLC(
const TDesC& aQuery)
{
MPX_FUNC("CMPXDbCategory::PreProcessStringLC");
HBufC* query = HBufC::NewLC(aQuery.Length() + KMaxTableNameCount *
(iTableName->Length() + KCategoryTablePlaceholder().Length()));
TPtr queryPtr(query->Des());
// copy the query string
queryPtr = aQuery;
// replace all instances of the placeholder with the actual table name
TInt index(0);
while ((index = queryPtr.Find(KCategoryTablePlaceholder)) != KErrNotFound)
{
queryPtr.Replace(index, KCategoryTablePlaceholder().Length(), *iTableName);
}
return query;
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::ProcessRecordsetL
// Unknown item is stored in the database as NULL (name field). This ensures the
// unknown item to be the 1st found record if it exists. This will save time in
// searching for the unknown record among the results and avoid performing
// descriptor comparison. If the 1st record is the unknown item, it won't be
// appended to the array until all other records have been put in the array.
//
// NOTE: putting unknown item to the end of the array only takes place when title
// field is requested. normal sorting algorithm occurs if title isn't
// requested.
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::ProcessRecordsetL(
const TArray<TMPXAttribute>& aAttrs,
RSqlStatement& aRecordset,
CMPXMediaArray& aMediaArray)
{
MPX_FUNC("CMPXDbCategory::ProcessRecordsetL");
// populate the array
TBool firstRecord(ETrue);
CMPXMedia* unknownMedia(NULL);
TInt prevId(0);
TInt err(KErrNone);
while ((err = aRecordset.Next()) == KSqlAtRow)
{
TUint32 rowId(aRecordset.ColumnInt64(ECategoryUniqueId));
if (prevId == rowId)
{
continue;
}
prevId = rowId;
CMPXMedia* media = CMPXMedia::NewL();
CleanupStack::PushL(media);
UpdateMediaL(aRecordset, aAttrs, *media);
if (firstRecord && (MPXDbCommonUtil::GetColumnTextL(aRecordset, ECategoryName).Length() == 0))
{
unknownMedia = media;
}
if (!firstRecord || !unknownMedia)
{
aMediaArray.AppendL(*media);
CleanupStack::PopAndDestroy(media);
}
firstRecord = EFalse;
} // end while
if (err != KSqlAtEnd)
{
User::LeaveIfError(err);
}
if (unknownMedia)
{
aMediaArray.AppendL(*unknownMedia);
CleanupStack::PopAndDestroy(unknownMedia);
}
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::CreateTableL
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::CreateTableL(
RSqlDatabase& aDatabase,
TBool /* aCorruptTable */)
{
MPX_FUNC("CMPXDbCategory::CreateTableL");
// create the table
HBufC* query = PreProcessStringLC(KCategoryCreateTable);
User::LeaveIfError(aDatabase.Exec(*query));
CleanupStack::PopAndDestroy(query);
// create the Name index
query = PreProcessStringLC(KCategoryNameIndex);
User::LeaveIfError(aDatabase.Exec(*query));
CleanupStack::PopAndDestroy(query);
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::DropTableL
// ----------------------------------------------------------------------------
//
void CMPXDbCategory::DropTableL(
RSqlDatabase& aDatabase)
{
MPX_FUNC("CMPXDbCategory::DropTableL");
HBufC* query = PreProcessStringLC(KCategoryDropTable);
User::LeaveIfError(aDatabase.Exec(*query));
CleanupStack::PopAndDestroy(query);
}
// ----------------------------------------------------------------------------
// CMPXDbCategory::CheckTableL
// ----------------------------------------------------------------------------
//
TBool CMPXDbCategory::CheckTableL(
RSqlDatabase& aDatabase)
{
MPX_FUNC("CMPXDbCategory::CheckTableL");
HBufC* query = PreProcessStringLC(KCategoryCheckTable);
TBool check(DoCheckTable(aDatabase, *query));
CleanupStack::PopAndDestroy(query);
return check;
}
// End of File