1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // HEADER FILES

    15 // 

    16 //

    17 

    18 

    19 /**

    20  * HEADER FILES

    21  */

    22 #include <barsc.h>

    23 #include <bautils.h>

    24 

    25 #include "msvdbadapter.h"

    26 #include "msventryfreepool.h"

    27 #include "msvsearchsortdbwrapper.h"

    28 

    29 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    30 #include "msvsearchsortconstants.h"

    31 #endif

    32 

    33 #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

    34 	#include "cmessageconvertermanager.h"

    35 #endif

    36 

    37 /**

    38  * CONSTANT DEFINITION

    39  */

    40 #define SERVER_UID 0x1000484B

    41 #define KMsvNumStdFolder 7

    42 

    43 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

    44 	#include "msvindexadapter.h"

    45 	

    46 	//Main (dummy) DB name.

    47 	#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

    48 		_LIT(KMainDummyDBName, "\\messaging_master.db");

    49 		_LIT(KMessagingDBName, "\\messaging.db");

    50 	#else

    51 		_LIT(KMainDummyDBName, "[1000484b]messaging_master.db");

    52 		_LIT(KMessagingDBName, "[1000484b]messaging.db");

    53 	#endif

    54 

    55 	_LIT(KLogicalName, "DB");

    56 	_LIT(KComma, ", ");

    57 	_LIT(KDelimiter, " ;");

    58 #endif		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

    59 

    60 

    61 /**

    62  * LITERAL DEFINITION

    63  */

    64 //Data definition queries

    65 _LIT8(KEncodingText, "encoding=UTF-8");

    66 _LIT8(KCreateIndexEntryTableQuery,	"CREATE TABLE IF NOT EXISTS IndexEntry ("

    67 								"id INTEGER PRIMARY KEY,"

    68 						  		"parentId INT,"

    69 								"serviceId INT,"

    70 								"mtmId INT,"

    71 								"type INT,"

    72 								"date INT64,"

    73 								"data INT,"

    74 								"size INT,"

    75 								"error INT,"

    76 								"mtmData1 INT,"

    77 								"mtmData2 INT,"

    78 								"mtmData3 INT,"

    79 								"relatedId INT,"

    80 								"bioType INT,"

    81 								"pcSyncCount INT,"

    82 								"reserved INT,"

    83 								"visibleParent INT,"

    84 								"description TEXT,"

    85 						  		"details TEXT" ");"

    86 	  );

    87 	  

    88 _LIT8(KCreateIndexQuery, "CREATE INDEX IF NOT EXISTS INDEX_PARENT ON IndexEntry(parentId);");

    89 _LIT8(KCreateVersionTableQuery, "CREATE TABLE IF NOT EXISTS VersionTable ( "

    90 									"version INTEGER PRIMARY KEY );"

    91 		);

    92 	

    93 //Common database queries

    94 _LIT8(KGetEntryExistsQuery, "SELECT parentId FROM IndexEntry WHERE id = :id;"); //

    95 _LIT8(KGetVisibleIdQuery, "SELECT data, visibleParent FROM IndexEntry WHERE id = :id;"); //

    96 _LIT8(KGetEntryQuery, "SELECT parentId, serviceId, mtmId, type, date, data, size, error, "

    97 						"mtmData1, mtmData2, mtmData3, relatedId, bioType, pcSyncCount, "

    98 						"reserved, visibleParent, description, details FROM IndexEntry WHERE id = :id;"); //

    99 _LIT8(KGetChildEntriesQuery, "SELECT id, serviceId, mtmId, type, date, data, size, error, "

   100 							"mtmData1, mtmData2, mtmData3, relatedId, bioType, pcSyncCount, "

   101 							"reserved, visibleParent, description, details FROM IndexEntry "

   102 							"WHERE parentId = :parentId order by id ASC;"); //

   103 		

   104 //Data manipulation queries

   105 _LIT8(KCreateEntryQuery,	 "INSERT INTO IndexEntry VALUES ("

   106 							 ":id, :parentId, :serviceId, :mtmId, :type, :date, :data, :size, :error,"

   107 							 ":mtmData1, :mtmData2, :mtmData3, :relatedId, :bioType, :pcSyncCount,"

   108 							 ":reserved, :visibleParent, :description, :details);"

   109 	 ); //

   110 _LIT8(KUpdateEntryQuery,	"UPDATE IndexEntry SET "

   111 							"parentId = :parentId, serviceId = :serviceId, mtmId = :mtmId, type = :type, date = :date,"

   112 							"data = :data, size = :size, error = :error, mtmData1 = :mtmData1, mtmData2 = :mtmData2,"

   113 							"mtmData3 = :mtmData3, relatedId = :relatedId, bioType = :bioType, pcSyncCount = :pcSyncCount,"

   114 							"reserved = :reserved, visibleParent = :visibleParent, description = :description,"

   115 							"details = :details WHERE id = :id;"

   116 	 ); //

   117 _LIT8(KUpdateEntryNoParentQuery,	"UPDATE IndexEntry SET "

   118 							"serviceId = :serviceId, mtmId = :mtmId, type = :type, date = :date,"

   119 							"data = :data, size = :size, error = :error, mtmData1 = :mtmData1, mtmData2 = :mtmData2,"

   120 							"mtmData3 = :mtmData3, relatedId = :relatedId, bioType = :bioType, pcSyncCount = :pcSyncCount,"

   121 							"reserved = :reserved, visibleParent = :visibleParent, description = :description,"

   122 							"details = :details WHERE id = :id;"

   123 	 ); //

   124 

   125 #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

   126 _LIT8(KCreateConversionStatusTableQuery, 	"CREATE TABLE IF NOT EXISTS ConversionStatus ("

   127 								"lastId INT,"

   128 						  		"serviceId INTEGER PRIMARY KEY,"

   129 								"sourceVersion INT,"

   130 								"targetVersion INT,"

   131 								"mtmId INT,"

   132 								"remainingCount INT );"

   133 	 );	

   134 

   135 _LIT8(KRemoveConversionStatusTable,  "DROP TABLE IF EXISTS ConversionStatus;");					

   136 

   137 

   138 

   139 #endif

   140 	 

   141 	 

   142 //Literals for parameter indexes

   143 _LIT(KMsgParamId, ":id");

   144 _LIT(KMsgParamParentId, ":parentId");

   145 _LIT(KMsgParamServiceId, ":serviceId");

   146 _LIT(KMsgParamMtmId, ":mtmId");

   147 _LIT(KMsgParamType, ":type");

   148 _LIT(KMsgParamDate, ":date");

   149 _LIT(KMsgParamData, ":data");

   150 _LIT(KMsgParamSize, ":size");

   151 _LIT(KMsgParamError, ":error");

   152 _LIT(KMsgParamMtmData1, ":mtmData1");

   153 _LIT(KMsgParamMtmData2, ":mtmData2");

   154 _LIT(KMsgParamMtmData3, ":mtmData3");

   155 _LIT(KMsgParamRelatedId, ":relatedId");

   156 _LIT(KMsgParamBiotype, ":bioType");

   157 _LIT(KMsgParamPcSyncCount, ":pcSyncCount");

   158 _LIT(KMsgParamReserved, ":reserved");

   159 _LIT(KMsgParamVisibleParent, ":visibleParent");

   160 _LIT(KMsgParamDescriptionTxt, ":description");

   161 _LIT(KMsgParamDetailsTxt, ":details");

   162 

   163 //Literals for column indexes

   164 _LIT(KMsgColumnId, "id");

   165 _LIT(KMsgColumnParentId, "parentId");

   166 _LIT(KMsgColumnServiceId, "serviceId");

   167 _LIT(KMsgColumnMtmId, "mtmId");

   168 _LIT(KMsgColumnType, "type");

   169 _LIT(KMsgColumnDate, "date");

   170 _LIT(KMsgColumnData, "data");

   171 _LIT(KMsgColumnSize, "size");

   172 _LIT(KMsgColumnError, "error");

   173 _LIT(KMsgColumnMtmData1, "mtmData1");

   174 _LIT(KMsgColumnMtmData2, "mtmData2");

   175 _LIT(KMsgColumnMtmData3, "mtmData3");

   176 _LIT(KMsgColumnRelatedId, "relatedId");

   177 _LIT(KMsgColumnBiotype, "bioType");

   178 _LIT(KMsgColumnPcSyncCount, "pcSyncCount");

   179 _LIT(KMsgColumnReserved, "reserved");

   180 _LIT(KMsgColumnVisibleParent, "visibleParent");

   181 _LIT(KMsgColumnDescriptionTxt, "description");

   182 _LIT(KMsgColumnDetailsTxt, "details");

   183 

   184 

   185 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   186 	_LIT8(KGetChildIdsQuery, "SELECT id, type, data FROM IndexEntry WHERE parentId = :parentId order by id ASC;"); //

   187 	_LIT8(KClearTableContents, "DELETE FROM SearchSortEntry;");

   188 #else

   189 	_LIT8(KDeleteTable,  "DROP TABLE IF EXISTS SearchSortEntry;");

   190 	_LIT8(KGetChildIdsQuery, "SELECT id FROM IndexEntry WHERE parentId = :parentId order by id ASC;"); //

   191 	_LIT8(KGetInPreparationIdQuery, "SELECT id, data FROM IndexEntry;");

   192 #endif

   193 

   194 

   195 

   196 // Changes for PREQ 1667.

   197 //Data definition queries for SearchSort-Table

   198 _LIT8(KCreateSearchSortEntryTableQuery,	"CREATE TABLE IF NOT EXISTS SearchSortEntry ("

   199 						"Qid INT,"

   200 				  		"id INT,"

   201 						"sortfield TEXT" ");"

   202 );

   203 

   204 _LIT8(KCreateSearchSortQuery, "CREATE UNIQUE INDEX IF NOT EXISTS SearchSortEntry_UNIQUE ON SearchSortEntry (Qid, id,sortfield);");

   205 

   206 //Common database queries

   207 _LIT8(KGetEntryAsc, "SELECT DISTINCT id FROM SearchSortEntry WHERE Qid = :Qid ORDER by sortfield ASC;");

   208 _LIT8(KGetEntryDesc, "SELECT DISTINCT id FROM SearchSortEntry WHERE Qid = :Qid ORDER by sortfield DESC;");

   209 _LIT8(KGetEntryNumAsc, "SELECT DISTINCT id FROM SearchSortEntry WHERE Qid = :Qid ORDER by CAST(sortfield AS INT) ASC;");

   210 _LIT8(KGetEntryNumDesc, "SELECT DISTINCT id FROM SearchSortEntry WHERE Qid = :Qid ORDER by CAST(sortfield AS INT) DESC;");

   211 

   212 _LIT8(KGetLastNIdsAsc, "SELECT DISTINCT id FROM SearchSortEntry WHERE ROWID > (LAST_INSERT_ROWID() - :RowId) AND Qid = :Qid ORDER by sortfield ASC;");

   213 _LIT8(KGetLastNIdsDesc, "SELECT DISTINCT id FROM SearchSortEntry WHERE ROWID > (LAST_INSERT_ROWID() - :RowId) AND Qid = :Qid ORDER by sortfield DESC;");

   214 _LIT8(KGetLastNIdsNumAsc, "SELECT DISTINCT id FROM SearchSortEntry WHERE ROWID > (LAST_INSERT_ROWID() - :RowId) AND Qid = :Qid ORDER by CAST(sortfield AS INT) ASC;");

   215 _LIT8(KGetLastNIdsNumDesc, "SELECT DISTINCT id FROM SearchSortEntry WHERE ROWID > (LAST_INSERT_ROWID() - :RowId) AND Qid = :Qid ORDER by CAST(sortfield AS INT) DESC;");

   216 

   217 _LIT8(KGetQueryCount, "SELECT COUNT(DISTINCT id) FROM SearchSortEntry WHERE Qid = :Qid");

   218 

   219 _LIT8(KGetFolderIds, "SELECT id FROM IndexEntry WHERE parentId = :parentId AND type LIKE :type");

   220 

   221 _LIT8(KGetIterResultCastAsc, "SELECT id FROM SearchSortEntry WHERE Qid = :qid ORDER by CAST(sortfield AS INT) ASC LIMIT :lim OFFSET :off ");

   222 _LIT8(KGetIterResultCastDesc, "SELECT id FROM SearchSortEntry WHERE Qid = :qid ORDER by CAST(sortfield AS INT) DESC LIMIT :lim OFFSET :off ");

   223 _LIT8(KGetIterResultAsc, "SELECT id FROM SearchSortEntry WHERE Qid = :qid ORDER by sortfield ASC LIMIT :lim OFFSET :off ");

   224 _LIT8(KGetIterResultDesc, "SELECT id FROM SearchSortEntry WHERE Qid = :qid ORDER by sortfield ASC LIMIT :lim OFFSET :off ");

   225 

   226 //Data manipulation queries

   227 _LIT8(KDeleteId, 	 "DELETE FROM SearchSortEntry WHERE id = ");

   228 _LIT8(KCreateQueryEntry,	 "INSERT OR IGNORE INTO SearchSortEntry VALUES ("

   229 							 ":Qid, :id, :sortfield);");

   230 

   231 _LIT8(KDeleteQueryId, 	 "DELETE FROM SearchSortEntry WHERE Qid = ");

   232 _LIT8(KAndId, " AND id = ");

   233 _LIT8(KSemiColon, ";");

   234 

   235 //Literals for parameter indexes

   236 _LIT(KQueryQId, ":Qid");

   237 _LIT(KQueryTMsvId, ":id");

   238 _LIT(KQuerySortfield, ":sortfield");

   239 _LIT(KQueryRowId, ":RowId");

   240 _LIT(KOffset, ":off");

   241 _LIT(KLimit, ":lim");

   242 

   243 //Literals for column indexes

   244 _LIT(KQueryColumnTMsvId, "id");

   245 

   246 

   247 

   248 /**

   249  * MEMBER FUNCTIONS OF CMsvDBAdapter

   250  */

   251 

   252 

   253 

   254 /**

   255  * CMsvDBAdapter()

   256  * The default Constructor. 

   257  */

   258 CMsvDBAdapter::CMsvDBAdapter():isTransactionOpen(EFalse)

   259 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   260 		,iDbPtrInitialized(EFalse)

   261 #endif

   262 	{

   263 	}

   264 

   265 

   266 

   267 

   268 /**

   269  * ~CMsvDBAdapter()

   270  * The default Destructor. 

   271  */

   272 CMsvDBAdapter::~CMsvDBAdapter()

   273 	{

   274 	//Close all RSqlStatement object.

   275 	for(TInt index = ECreateEntry; index < EIndexSentinel; index++)

   276 		{

   277 		iStatement[index].Close();

   278 		}

   279 

   280 	for(TInt index = EQueryCreateEntry; index < EQuerySentinel; index++)

   281 		{

   282 		iQueryStatement[index].Close();

   283 		}

   284 		

   285 	iDatabase.Close();

   286 	

   287 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   288 	if(iDatabasePresent)

   289 		{

   290 		iDatabasePresent->Close();

   291 		delete iDatabasePresent;

   292 		}

   293 #endif

   294 	}

   295 

   296 

   297 

   298 

   299 // Code added in PREQ 557.

   300 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   301 

   302 /**

   303  * NewL()

   304  * @param None.

   305  * @return None.

   306  * 

   307  * Allocates and constructs a new DBAdapter object, calls ConstructL 

   308  * to create the dummy database and returns a handle to the DBAdapter.

   309  */

   310 CMsvDBAdapter* CMsvDBAdapter::NewL()

   311 	{

   312 	//Create the DBAdapter object.

   313 	CMsvDBAdapter* self = new(ELeave) CMsvDBAdapter();

   314 	CleanupStack::PushL(self);

   315 	

   316 	// Create the database.

   317 	self->ConstructL();

   318 	

   319 	CleanupStack::Pop(self);

   320 	return self;

   321 	

   322 	}

   323 

   324 

   325 

   326 

   327 /**

   328  * ConstructL()

   329  * @param None.

   330  * @return None.

   331  * 

   332  * Checks if there is the main (dummy) DB in the system drive

   333  * and creates one if it is not present. Other databases will

   334  * be attached to this DB which will not get deleted during

   335  * the operation of the message server.

   336  */

   337 void CMsvDBAdapter::ConstructL()

   338 	{

   339 	//Get the system drive.

   340 	TInt systemDrive = (TInt)RFs::GetSystemDrive();

   341 	

   342 	RBuf dbFile;

   343 	CleanupClosePushL(dbFile);

   344 	dbFile.CreateL(50);	

   345 	dbFile.Append(TDriveUnit(systemDrive).Name());

   346 	dbFile.Append(KMainDummyDBName);

   347 	

   348 	//Check if the main DB exists. If not, then create it.

   349 	// > KErrNotFound, KErrPathNotFound - DB doesn't exist.

   350 	// > KErrNone, KErrInUse - DB exists.

   351 	TRAPD(err, iDatabase.OpenL(dbFile));

   352 	if(KErrNone != err)

   353 		{

   354 		

   355 		// Leave in unfavorable condition.

   356 		if(KErrNoMemory == err ||

   357 		   KErrNotReady == err ||

   358 		   KErrInUse    == err

   359 		  )

   360 			{

   361 			User::Leave(err);

   362 			}

   363 

   364 		HBufC8* heapBuf = KEncodingText().AllocLC();

   365 		

   366 		if(KSqlErrCorrupt == err || KSqlErrNotDb == err)

   367 			{

   368 			RSqlDatabase::Delete(dbFile);

   369 			}

   370 		

   371 		//Create the dummy DB.		

   372 #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   373 		// Create the non-secure database.

   374 		User::LeaveIfError(iDatabase.Create(dbFile, heapBuf));

   375 #else

   376 		// Using SID based security policy.

   377 		TSecureId sid(SERVER_UID);

   378 		const TSecurityPolicy KDefaultPolicy(sid);

   379 	

   380 		//Create security policy

   381 		RSqlSecurityPolicy securityPolicy;

   382 		CleanupClosePushL(securityPolicy);	

   383 		

   384 		User::LeaveIfError(securityPolicy.Create(KDefaultPolicy));

   385 		User::LeaveIfError(iDatabase.Create(dbFile, securityPolicy, heapBuf));

   386 		CleanupStack::PopAndDestroy(); //securityPolicy

   387 #endif		// #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   388 

   389 		CleanupStack::PopAndDestroy(); //heapBuf

   390 		}

   391 	CleanupStack::PopAndDestroy(); //dbFile

   392 			

   393 	//Construct the data structure to store maximum TMsvIds in

   394 	//a given driveId.

   395 	iDatabasePresent = new(ELeave)RArray<TBool>(KMaxNumberOfDrives);

   396 	//Initialisation.

   397 	for(TInt index = 0; index < KMaxNumberOfDrives; ++index)

   398 		{

   399 		iDatabasePresent->Append(EFalse);

   400 		}

   401 	

   402 	}

   403 	

   404 

   405 

   406 

   407 /**

   408  * AttachDBL()

   409  * @param TDriveUnit The drive information of the drive to be checked.

   410  * @param TUint The driveId of the drive (0-7).

   411  * @param TMsvId& An output parameter that gives the maximum TMsvId of an 

   412  *				  entry in the messaging database of that drive.

   413  * 

   414  * Attaches a database on the specified drive to the main (dummy) 

   415  * database on the system drive so that appropriate queries 

   416  * access entries in that database too. The function calls MaxTMsvIdL()

   417  * to query the particular database to get the maximum TMsvId of an entry 

   418  * stored in it. This TMsvId is maintained in a data structure which has 

   419  * the driveId as the index.

   420  *

   421  * The database is detached by using its logical name which can

   422  * be obtained from the driveId.

   423  * (E.g.: logical name of a database on driveId 3 is 'DB3'. A query on the

   424  * IndexEntry in this database should address the table as DB3.IndexEntry.)

   425  */

   426 #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)	

   427 void CMsvDBAdapter::AttachDBL(TDriveUnit aDriveUnit, TUint aDriveId, TMsvId& aMaxId, CMsvMessageDBAdapter* iMessageDBAdapter/*default= NULL*/)

   428 #else

   429 void CMsvDBAdapter::AttachDBL(TDriveUnit aDriveUnit, TUint aDriveId, TMsvId& aMaxId)

   430 #endif

   431 	{

   432 	//Construct the logical name of the database to be attached from 

   433 	//the driveId.

   434 	RBuf logicalName;

   435 	CleanupClosePushL(logicalName);

   436 	logicalName.CreateL(5);	

   437 	logicalName.Append(KLogicalName);

   438 	logicalName.AppendNum(aDriveId);

   439 		

   440 	//Construct the DB filename appending messaging DB name to the drive name.

   441 	RBuf dbFile;

   442 	CleanupClosePushL(dbFile);

   443 	dbFile.CreateL(50);	

   444 	dbFile.Append(aDriveUnit.Name());

   445 	dbFile.Append(KMessagingDBName);

   446 	

   447 	//Attach the database to the connection.

   448 	User::LeaveIfError(iDatabase.Attach(dbFile, logicalName));

   449 	

   450 	//Find the parameter and column indexes just once.

   451 	if((KErrNotFound == iDatabasePresent->Find(ETrue)) && (!iDbPtrInitialized))

   452 		{

   453 		InitializeL();

   454 		iDbPtrInitialized = ETrue;

   455 		}

   456 		

   457 	//Find the maximum TMsvId in the database and store it.

   458 	aMaxId = MaxTMsvIdL(aDriveId);

   459 	(*iDatabasePresent)[aDriveId] = ETrue;

   460 	

   461 #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

   462 	if(iMessageDBAdapter)

   463 		{

   464 		iMessageDBAdapter->UpdateMetadataStructureL(aDriveId);		

   465 		}	

   466 #endif

   467 

   468 	CleanupStack::PopAndDestroy(2); //logicalName, dbFile	

   469 	}

   470 

   471 	

   472 

   473 	

   474 /**

   475  * DetachDBL()

   476  * @param TUint The driveId (0-7) of the drive from which the database

   477  * 				is to be detached.

   478  * @return None.

   479  *

   480  * Detaches a database on the drive specified by the driveId from

   481  * the main database connection. This is done when:

   482  * a. The disk is removed from the drive.

   483  * b. The drive is removed from the preferred drive list.

   484  *

   485  * The database is detached by using its logical name which can

   486  * be obtained from the driveId.

   487  * (E.g.: logical name of a database on driveId 3 is 'DB3'.)

   488  */

   489 void CMsvDBAdapter::DetachDBL(TUint aDriveId)

   490 	{

   491 	//Construct the logical name.

   492 	RBuf logicalName;

   493 	CleanupClosePushL(logicalName);

   494 	logicalName.CreateL(5);	

   495 	logicalName.Append(KLogicalName);

   496 	logicalName.AppendNum(aDriveId);

   497 	

   498 	User::LeaveIfError(iDatabase.Detach(logicalName));

   499 	

   500 	CleanupStack::PopAndDestroy(); //logicalName

   501 	

   502 	(*iDatabasePresent)[aDriveId] = EFalse;

   503 	

   504 	}

   505 

   506 

   507 

   508 

   509 /**

   510  * CreateDBL()

   511  * @param TDriveNumber The drive number of the drive on which a 

   512  *						a new messaging database is to be created.

   513  * @return None.

   514  *

   515  * Creates the messaging database on the drive specified by the TDriveNumber

   516  * using a temporary local database connection.

   517  * Also creates the IndexEntry table and an index on the parentId field in it,

   518  * and then the Root entry in the database.

   519  * Also creates a version table, which is a database with just one column

   520  * and row which stores the current database version for message store

   521  * versioning.

   522  */

   523 #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   524 void CMsvDBAdapter::CreateDBL(TDriveNumber aDriveNumber, TBool aCreateVersionTable /*Default=ETrue*/, TBool aInvalid /*Default=EFalse*/)

   525 #else

   526 void CMsvDBAdapter::CreateDBL(TDriveNumber aDriveNumber)

   527 #endif

   528 	{

   529 	//Construct the database filename.

   530 	TParse parse;

   531 	TPtrC drive = TDriveUnit(aDriveNumber).Name();

   532 	parse.Set(KMessagingDBName, &drive, NULL);

   533 	TFileName dbFileName = parse.FullName();

   534 	

   535 	RSqlDatabase tempDB; //A temporary local database connection.

   536 	CleanupClosePushL(tempDB);

   537 

   538 	HBufC8* heapBuf = KEncodingText().AllocLC();

   539 

   540 	//Create the database.

   541 #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   542 	User::LeaveIfError(tempDB.Create(dbFileName, heapBuf));

   543 #else	

   544 	// Using SID based security policy.

   545 	TSecureId sid(SERVER_UID);

   546 	const TSecurityPolicy KDefaultPolicy(sid);

   547 	

   548 	//Create security policy

   549 	RSqlSecurityPolicy securityPolicy;

   550 	CleanupClosePushL(securityPolicy);	

   551 		

   552 	User::LeaveIfError(securityPolicy.Create(KDefaultPolicy));

   553 	User::LeaveIfError(tempDB.Create(dbFileName, securityPolicy, heapBuf));

   554 	

   555 	CleanupStack::PopAndDestroy(); //securityPolicy

   556 #endif		// #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   557 

   558 	CleanupStack::PopAndDestroy(); //heapBuf

   559 	

   560 	//Create tables for the database

   561 	TInt err = tempDB.Exec(KCreateIndexEntryTableQuery);

   562 	if(err < 0)

   563 		{

   564 		User::Leave(err);

   565 		}

   566 	else if(!err)

   567 		{

   568 		User::Leave(KErrGeneral);

   569 		}

   570 		

   571 	//Create index on indexEnty table.

   572 	//Index is created on parentId.

   573 	err = tempDB.Exec(KCreateIndexQuery);

   574 	if(err < 0)

   575 		{

   576 		User::Leave(err);

   577 		}

   578 	else if(!err)

   579 		{

   580 		User::Leave(KErrGeneral);

   581 		}

   582 	

   583 	// Create root entry in DB.

   584 	CreateRootEntryL(tempDB);	

   585 

   586 #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   587 	if(aCreateVersionTable)

   588 		{

   589 #endif

   590 	//Create the version table to store the message store version.

   591 	err = tempDB.Exec(KCreateVersionTableQuery);

   592 	if(err < 0)

   593 		{

   594 		User::Leave(err);

   595 		}

   596 	else if(!err)

   597 		{

   598 		User::Leave(KErrGeneral);

   599 		}

   600 	//Insert the version number into the above table.

   601 	_LIT(KInsertVersionNumberQuery, " INSERT INTO VersionTable Values ( " );

   602 	RBuf8 versionQuery;

   603 	CleanupClosePushL(versionQuery);

   604 	versionQuery.CreateL(50);

   605 	versionQuery.Append(KInsertVersionNumberQuery);

   606 

   607 #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   608 	if(aInvalid) //create an invalid database wrt version for testing

   609 		versionQuery.AppendNum(999);

   610 	else

   611 		versionQuery.AppendNum(KCurrentDatabaseVersion);	

   612 #else

   613 	versionQuery.AppendNum(KCurrentDatabaseVersion);	

   614 #endif

   615 

   616 	versionQuery.Append(_L(");"));

   617 	err = tempDB.Exec(versionQuery);

   618 	if(err < 0)

   619 		{

   620 		User::Leave(err);

   621 		}

   622 	else if(!err)

   623 		{

   624 		User::Leave(KErrGeneral);

   625 		}

   626 

   627 	CleanupStack::PopAndDestroy();	//versionQuery

   628 		

   629 #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)		

   630 		}

   631 #endif

   632 	

   633 	CleanupStack::PopAndDestroy(); // tempDB

   634 	}

   635  

   636  

   637 

   638 /**

   639  * CreateRootEntryL()

   640  *

   641  * Creates root entry in the DB.

   642  */

   643 void CMsvDBAdapter::CreateRootEntryL(RSqlDatabase& tempDB)

   644 	{

   645 	_LIT(KCreateRootEntryQuery, "INSERT INTO IndexEntry VALUES (");

   646 	_LIT(KComma, ", ");

   647 	_LIT(KDelimiter, " );");

   648 	

   649 	TMsvEntry rootEntry;

   650 	rootEntry.iType = KUidMsvRootEntry;

   651 	rootEntry.iMtm = KUidMsvRootEntry;

   652 	rootEntry.iDate.UniversalTime();

   653 	rootEntry.SetId(KMsvRootIndexEntryId);

   654 	rootEntry.SetParent(KErrNotFound);

   655 	rootEntry.SetOwner(ETrue);

   656 	rootEntry.iSize = 0;

   657 	

   658 	RBuf queryBuf;

   659 	CleanupClosePushL(queryBuf);

   660 	queryBuf.CreateL(300);	

   661 	queryBuf.Append(KCreateRootEntryQuery);

   662 	queryBuf.AppendNum(rootEntry.iId);

   663 	queryBuf.Append(KComma);

   664 	queryBuf.AppendNum(rootEntry.Parent());

   665 	queryBuf.Append(KComma);

   666 	queryBuf.AppendNum(rootEntry.iServiceId);

   667 	queryBuf.Append(KComma);

   668 	queryBuf.AppendNum(rootEntry.iMtm.iUid);

   669 	queryBuf.Append(KComma);

   670 	queryBuf.AppendNum(rootEntry.iType.iUid);

   671 	queryBuf.Append(KComma);

   672 	queryBuf.AppendNum(rootEntry.iDate.Int64());

   673 	queryBuf.Append(KComma);

   674 	queryBuf.AppendNum(rootEntry.iData);

   675 	queryBuf.Append(KComma);

   676 	queryBuf.AppendNum(rootEntry.iSize);

   677 	queryBuf.Append(KComma);

   678 	queryBuf.AppendNum(rootEntry.iError);

   679 	queryBuf.Append(KComma);

   680 	queryBuf.AppendNum(rootEntry.iMtmData1);

   681 	queryBuf.Append(KComma);

   682 	queryBuf.AppendNum(rootEntry.iMtmData2);

   683 	queryBuf.Append(KComma);

   684 	queryBuf.AppendNum(rootEntry.iMtmData3);

   685 	queryBuf.Append(KComma);

   686 	queryBuf.AppendNum(rootEntry.iRelatedId);

   687 	queryBuf.Append(KComma);

   688 	queryBuf.AppendNum(rootEntry.iBioType);

   689 	queryBuf.Append(KComma);

   690 	queryBuf.AppendNum(rootEntry.iPcSyncCount);

   691 	queryBuf.Append(KComma);

   692 	queryBuf.AppendNum(rootEntry.iReserved);

   693 	queryBuf.Append(KComma);

   694 	queryBuf.AppendNum(KMsvRootIndexEntryId);

   695 	queryBuf.Append(KComma);

   696 	queryBuf.Append(_L("\"\""));

   697 	queryBuf.Append(KComma);

   698 	queryBuf.Append(_L("\"\""));

   699 	queryBuf.Append(KDelimiter);

   700 	

   701 	TInt err = tempDB.Exec(queryBuf);

   702 	if(err < 0)

   703 		{

   704 		User::Leave(err);

   705 		}

   706 	else if(!err)

   707 		{

   708 		User::Leave(KErrGeneral);

   709 		}

   710 	CleanupStack::PopAndDestroy(); //queryBuf	

   711 	}

   712 	

   713 	

   714 	

   715 

   716 /**

   717  * MaxTMsvIdL()

   718  * @param TDriveNumber The drive number of the drive to be queried.

   719  * @return None.

   720  *

   721  * Queries the specified drive's database for the maximum TMsvId

   722  * of an entry stored in it.

   723  */

   724 TMsvId CMsvDBAdapter::MaxTMsvIdL(TUint aDriveId)

   725 	{	 

   726 	_LIT(KMaxTMsvIdQuery1, "SELECT MAX(id) FROM DB");

   727 	_LIT(KMaxTMsvIdQuery2, ".IndexEntry;");

   728 	

   729 	RBuf queryBuf;

   730 	CleanupClosePushL(queryBuf);

   731 	queryBuf.CreateL(50);	

   732 	

   733 	queryBuf.Append(KMaxTMsvIdQuery1);

   734 	queryBuf.AppendNum(aDriveId);

   735 	queryBuf.Append(KMaxTMsvIdQuery2);

   736 	

   737 	//Create a select query

   738     TSqlScalarFullSelectQuery query(iDatabase);

   739 

   740 	//Get the column data

   741     TMsvId maxTMsvId = query.SelectIntL(queryBuf);

   742     

   743     CleanupStack::PopAndDestroy(); //queryBuf

   744     

   745     if(KMsvRootIndexEntryId != maxTMsvId)

   746     	maxTMsvId = MaskTMsvId(aDriveId, maxTMsvId);

   747     return maxTMsvId;

   748 	}

   749 

   750 

   751 

   752 

   753 /**

   754  * ValidateDatabaseL()

   755  * @param TDriveNumber The drive number of the drive to be checked.

   756  * @return None.

   757  *

   758  * Validates a database by checking if:

   759  * a. The database file is in the appropriate location.

   760  * b. The database is readable and not corrupt.

   761  * c. The database is of latest supported version.

   762  * d. All standard folders (as specified in the messaging resource file)

   763  *    exist in the database.

   764  */

   765 void CMsvDBAdapter::ValidateDatabaseL(TDriveNumber aDriveNumber)

   766 	{

   767 	//Check (a) and (b).

   768 	TParse parse;

   769 	TPtrC drive(TDriveUnit(aDriveNumber).Name());

   770 	parse.Set(KMessagingDBName, &drive, NULL);

   771 	TFileName dbFile = parse.FullName();

   772 	

   773 	RSqlDatabase tempDB;

   774 	CleanupClosePushL(tempDB);

   775 	tempDB.OpenL(dbFile);

   776 		

   777 	//Check (d) with the connection still open.

   778 	//Entries to be checked are Root, Local, Inbox, Outbox, Drafts,

   779 	//Sent and Deleted.

   780 	_LIT(KStandardEntryExistsQuery1, "SELECT count(*) FROM IndexEntry WHERE id <= ");

   781 	RBuf queryBuf;	

   782 	CleanupClosePushL(queryBuf);

   783 	queryBuf.CreateL(150);

   784 	queryBuf.Append(KStandardEntryExistsQuery1);

   785 	queryBuf.AppendNum(KMsvDeletedEntryFolderEntryId);

   786 	queryBuf.Append(KDelimiter);

   787 	

   788 	TSqlScalarFullSelectQuery query(tempDB);

   789 	TInt folders = 0;

   790 	folders = query.SelectIntL(queryBuf);

   791 	

   792 	//The database is invalid if the number of folders returned

   793 	//from the above query is not 7.

   794 	if(folders != KMsvNumStdFolder) //Number of standard folders + root. To be put in a macro or const

   795 		{

   796 		User::Leave(KSqlErrCorrupt); 

   797 		}

   798 	CleanupStack::PopAndDestroy(); //queryBuf	

   799 	

   800 	//(a), (b) and (d) are fine. Check (c).

   801 	//Check the version number against the expected version number.

   802 	//PREQ557 version - 1; Post-557 version - 2.

   803 	_LIT(KSelectVersionQuery, "SELECT version FROM VersionTable;");

   804 	TInt version = 0;

   805 	

   806 	version = query.SelectIntL(KSelectVersionQuery);

   807 	if(version != KCurrentDatabaseVersion)

   808 		{

   809 		User::Leave(KErrNotSupported);

   810 		}

   811 	

   812 	CleanupStack::PopAndDestroy();  // tempDB

   813 	}

   814 

   815 

   816 

   817 

   818 /**

   819  * GetVisibleFolderIdL()

   820  * @param TMsvId: Parent Id.

   821  * @param TMsvId&: Out parameter for most immediate visible folder id of

   822  *				   any child entry present under passed parent id.

   823  * @return None. 

   824  *

   825  * This functions returns the most immediate parent visible folder id.

   826  * There are two types of folders. A visible folder is one which is 

   827  * visible to the external user, but there are internal non-visible folders

   828  * created under each email message to organize the content of the email.

   829  * Parent entry of an entry is either root or a folder. A folder can be 

   830  * service folder (like LocalServices), user-defined folder/standard folder

   831  * like Inbox or a non-visible folder (created under an email message).

   832  * 

   833  * For a given parent Id, the function returns the most immediate visible

   834  * parent folder. The rules are as follows:

   835  * 1. If the parent entry is root or children of root, then the visibleFolder 

   836  * will be root itself. This is because service folders are considered 

   837  * invisible, since they are not seen by user. 

   838  * 2. If the parent entry itself is a visible folder then child's visibleFolder

   839  * id should be its parent id.

   840  * 3. If the parent entry is a non-visible folder then child's visibleFolder

   841  * id is same as its parent's visibleFolder id.

   842  */

   843 void CMsvDBAdapter::GetVisibleFolderIdL(TMsvId aParentId, TMsvId& aVisibleFolderId)

   844 	{

   845 	// If the entry is either a root entry (parent=KErrNotFound) or 

   846 	// child of root entry its visibleFolderId will be root entry itself.

   847 	if(KErrNotFound == aParentId)

   848 		{

   849 		aVisibleFolderId = KMsvRootIndexEntryId;

   850 		return;		

   851 		}

   852 

   853 	//Get the driveId and unmask the TMsvId supplied.

   854 	TInt driveId = GetDriveId(aParentId);

   855 	aParentId = UnmaskTMsvId(aParentId);

   856 

   857 	if(KMsvRootIndexEntryId == aParentId)

   858 		{

   859 		aVisibleFolderId = KMsvRootIndexEntryId;

   860 		}

   861 	else

   862 		{

   863 		//Construct a query for the particular drive.

   864 		_LIT8(KGetVisibleIdQuery1, "SELECT data, visibleParent FROM DB");

   865 		_LIT8(KGetVisibleIdQuery2, ".IndexEntry WHERE id = ");

   866 		

   867 		RBuf8 queryBuf;

   868 		CleanupClosePushL(queryBuf);

   869 		queryBuf.CreateL(70);		

   870 		queryBuf.Append(KGetVisibleIdQuery1);

   871 		queryBuf.AppendNum(driveId);

   872 		queryBuf.Append(KGetVisibleIdQuery2);

   873 		queryBuf.AppendNum(aParentId);

   874 		queryBuf.Append(KDelimiter);

   875 		

   876 		RSqlStatement visQuery;

   877 		CleanupClosePushL(visQuery);

   878 		User::LeaveIfError(visQuery.Prepare(iDatabase, queryBuf));

   879 		TInt dataParam = GetColumnIndexL(visQuery, KMsgColumnData());

   880 		TInt visParam = GetColumnIndexL(visQuery, KMsgColumnVisibleParent());

   881 		

   882 		if (KSqlAtRow != visQuery.Next())

   883 			{

   884 			User::Leave(KErrNotFound);

   885 			}

   886 		

   887 		TInt32 data = ColumnInt(visQuery, dataParam);

   888 		if( data & TMsvEntry::KMsvVisibleFolderNodeFlag)

   889 			{

   890 			// If visible folder flag is not set for parent entry.

   891 			aVisibleFolderId = ColumnInt(visQuery, visParam);

   892 			if(!IsStandardId(aVisibleFolderId))

   893 				{

   894 				aVisibleFolderId = MaskTMsvId(driveId, aVisibleFolderId);

   895 				}

   896 			}

   897 		else

   898 			{

   899 			// If parent entry is visible

   900 			if(IsStandardId(aParentId))

   901 				{

   902 				aVisibleFolderId = aParentId;				

   903 				}

   904 			else

   905 				{

   906 				aVisibleFolderId = MaskTMsvId(driveId, aParentId);

   907 				}

   908 			}		

   909 		CleanupStack::PopAndDestroy(2); //visQuery, queryBuf

   910 		}

   911 	}

   912 

   913 

   914 

   915 

   916 /**

   917  * CreateEntryL()

   918  * @param const TMsvEntry&: The entry to be created.

   919  * @param const TMsvId: Immediate visible parent folder of the entry

   920  * @return None.

   921  *

   922  * The function creates a new entry in the database.

   923  * No consisitency check is performed on the passed entry. The function may

   924  * leave if query execution fails.

   925  */

   926 void CMsvDBAdapter::CreateEntryL(const TMsvEntry& aNewEntry, const TMsvId aImmediateVisibleFolder)

   927 	{

   928 	_LIT8(KCreateEntryQuery1,	 "INSERT INTO DB");

   929 	_LIT8(KCreateEntryQuery2, ".IndexEntry VALUES ("

   930 							  ":id, :parentId, :serviceId, :mtmId, :type, :date, :data, :size, :error,"

   931 							  ":mtmData1, :mtmData2, :mtmData3, :relatedId, :bioType, :pcSyncCount,"

   932 							  ":reserved, :visibleParent, :description, :details);"

   933 		 );

   934 

   935 	//Get the driveId and unmask the TMsvId supplied.

   936 	TInt driveId = GetDriveId(aNewEntry.iId);

   937 	TMsvId id = UnmaskTMsvId(aNewEntry.iId);

   938 	TMsvId parentId = UnmaskTMsvId(aNewEntry.iParentId);

   939 	TMsvId visFolder = UnmaskTMsvId(aImmediateVisibleFolder);

   940 	TMsvId serviceId = UnmaskTMsvId(aNewEntry.iServiceId);

   941 	TMsvId relatedId = UnmaskTMsvId(aNewEntry.iRelatedId);

   942 	

   943 	//Construct a query for the particular drive.

   944 	RBuf8 queryBuf;

   945 	CleanupClosePushL(queryBuf);

   946 	queryBuf.CreateL(350);

   947 	queryBuf.Append(KCreateEntryQuery1);

   948 	queryBuf.AppendNum(driveId);

   949 	queryBuf.Append(KCreateEntryQuery2);

   950 	iStatement[ECreateEntry].Close(); //closing any statement prepared previously

   951 	User::LeaveIfError(iStatement[ECreateEntry].Prepare(iDatabase, queryBuf));

   952 	

   953 	//Bind the entry data

   954 	BindIntL(iStatement[ECreateEntry], iIdIndex[ECreateEntry], id);

   955 	BindIntL(iStatement[ECreateEntry], iParentIdIndex[ECreateEntry], parentId);

   956 	BindIntL(iStatement[ECreateEntry], iDataIndex[ECreateEntry], aNewEntry.iData);

   957 	BindIntL(iStatement[ECreateEntry], iPcSyncCountIndex[ECreateEntry], aNewEntry.iPcSyncCount);

   958 	BindIntL(iStatement[ECreateEntry], iReservedIndex[ECreateEntry], aNewEntry.iReserved);

   959 	BindIntL(iStatement[ECreateEntry], iRelatedIdIndex[ECreateEntry], relatedId);

   960 	BindIntL(iStatement[ECreateEntry], iTypeIndex[ECreateEntry], aNewEntry.iType.iUid);

   961 	BindInt64L(iStatement[ECreateEntry], iDateIndex[ECreateEntry], aNewEntry.iDate.Int64());

   962 	BindIntL(iStatement[ECreateEntry], iSizeIndex[ECreateEntry], aNewEntry.iSize);

   963 	BindIntL(iStatement[ECreateEntry], iErrorIndex[ECreateEntry], aNewEntry.iError);

   964 	BindIntL(iStatement[ECreateEntry], iBiotypeIndex[ECreateEntry], aNewEntry.iBioType);

   965 	BindIntL(iStatement[ECreateEntry], iMtmData1Index[ECreateEntry], aNewEntry.iMtmData1);

   966 	BindIntL(iStatement[ECreateEntry], iMtmData2Index[ECreateEntry], aNewEntry.iMtmData2);

   967 	BindIntL(iStatement[ECreateEntry], iMtmData3Index[ECreateEntry], aNewEntry.iMtmData3);

   968 	BindIntL(iStatement[ECreateEntry], iServiceIdIndex[ECreateEntry], serviceId);

   969 	BindIntL(iStatement[ECreateEntry], iMtmIdIndex[ECreateEntry], aNewEntry.iMtm.iUid);

   970 	BindIntL(iStatement[ECreateEntry], iVisibleParent[ECreateEntry], visFolder);

   971 	BindTextL(iStatement[ECreateEntry],iDescriptionIndex[ECreateEntry],aNewEntry.iDescription);

   972 	BindTextL(iStatement[ECreateEntry],iDetailsIndex[ECreateEntry],aNewEntry.iDetails);

   973 	

   974 	TInt err = iStatement[ECreateEntry].Exec();

   975 	if(err < 0)

   976 		{

   977 		User::Leave(err);

   978 		}

   979 	else if(!err)

   980 		{

   981 		User::Leave(KErrGeneral);

   982 		}

   983 	iStatement[ECreateEntry].Close();

   984 	CleanupStack::PopAndDestroy();

   985 	}

   986 

   987 

   988 

   989 

   990 /**

   991  * UpdateEntryL()

   992  * @param const TMsvEntry&: Entry to be updated.

   993  * @param const TMsvId: the visible folder Id of the updated entry.

   994  * @param TBool: ETrue if the parent of the entry has been changed,

   995  *				 EFalse if otherwise.

   996  * @return None.

   997  *

   998  * The function updates an entry in the database.

   999  * No consisitency check is performed on the passed entry. The function may

  1000  * leave if query execution fails.

  1001  */

  1002 void CMsvDBAdapter::UpdateEntryL(const TMsvEntry& aEntry, const TMsvId aImmediateVisibleFolder, TBool aIsParentIdUpdated/*DEFAULT=ETrue*/)

  1003 	{

  1004 	_LIT8(KUpdateEntryQuery1,	"UPDATE DB");

  1005 	_LIT8(KUpdateEntryQuery2, ".IndexEntry SET ");

  1006 	_LIT8(KUpdateEntryQueryWithParent,	"parentId = :parentId, ");

  1007 	_LIT8(KUpdateEntryQueryWithoutParent,	"serviceId = :serviceId, mtmId = :mtmId, type = :type, date = :date,"

  1008 							"data = :data, size = :size, error = :error, mtmData1 = :mtmData1, mtmData2 = :mtmData2,"

  1009 							"mtmData3 = :mtmData3, relatedId = :relatedId, bioType = :bioType, pcSyncCount = :pcSyncCount,"

  1010 							"reserved = :reserved, visibleParent = :visibleParent, description = :description,"

  1011 							"details = :details WHERE id = :id;"

  1012 		 );

  1013 	

  1014 	//Get the driveId and unmask the TMsvId supplied.

  1015 	TInt driveId = GetDriveId(aEntry.iId);

  1016 	TMsvId id = UnmaskTMsvId(aEntry.iId);

  1017 	TMsvId parentId = UnmaskTMsvId(aEntry.iParentId);

  1018 	TMsvId serviceId = UnmaskTMsvId(aEntry.iServiceId);

  1019 	TMsvId relatedId = UnmaskTMsvId(aEntry.iRelatedId);

  1020 	TMsvId visFolder = UnmaskTMsvId(aImmediateVisibleFolder);

  1021 	

  1022 	//Form the query for the particular drive.

  1023 	RBuf8 queryBuf;

  1024 	CleanupClosePushL(queryBuf);

  1025 	queryBuf.CreateL(500);	

  1026 	queryBuf.Append(KUpdateEntryQuery1);

  1027 	queryBuf.AppendNum(driveId);

  1028 	queryBuf.Append(KUpdateEntryQuery2);

  1029 

  1030 	iStatementType updateStmt;

  1031 	TInt err = KErrNone;

  1032 	//Bind the entry data

  1033 	if(aIsParentIdUpdated)

  1034 		{

  1035 		updateStmt = EUpdateEntry;

  1036 		queryBuf.Append(KUpdateEntryQueryWithParent);

  1037 		queryBuf.Append(KUpdateEntryQueryWithoutParent);

  1038 		iStatement[updateStmt].Close(); //closing any statement prepared previously

  1039 		User::LeaveIfError(iStatement[updateStmt].Prepare(iDatabase, queryBuf));

  1040 		BindIntL(iStatement[updateStmt], iParentIdIndex[updateStmt], parentId);

  1041 		}

  1042 	else

  1043 		{

  1044 		updateStmt = EUpdateEntryNoParent;

  1045 		iStatement[updateStmt].Close(); //closing any statement prepared previously

  1046 		queryBuf.Append(KUpdateEntryQueryWithoutParent);

  1047 		User::LeaveIfError(iStatement[updateStmt].Prepare(iDatabase, queryBuf));

  1048 		}

  1049 	BindIntL(iStatement[updateStmt], iVisibleParent[updateStmt], visFolder);

  1050 	BindIntL(iStatement[updateStmt], iIdIndex[updateStmt], id);

  1051 	BindIntL(iStatement[updateStmt], iDataIndex[updateStmt], aEntry.iData);

  1052 	BindIntL(iStatement[updateStmt], iPcSyncCountIndex[updateStmt], aEntry.iPcSyncCount);

  1053 	BindIntL(iStatement[updateStmt], iReservedIndex[updateStmt], aEntry.iReserved);

  1054 	BindIntL(iStatement[updateStmt], iRelatedIdIndex[updateStmt], relatedId);

  1055 	BindIntL(iStatement[updateStmt], iTypeIndex[updateStmt], aEntry.iType.iUid);

  1056 	BindInt64L(iStatement[updateStmt], iDateIndex[updateStmt], aEntry.iDate.Int64());

  1057 	BindIntL(iStatement[updateStmt], iSizeIndex[updateStmt], aEntry.iSize);

  1058 	BindIntL(iStatement[updateStmt], iErrorIndex[updateStmt], aEntry.iError);

  1059 	BindIntL(iStatement[updateStmt], iBiotypeIndex[updateStmt], aEntry.iBioType);

  1060 	BindIntL(iStatement[updateStmt], iMtmData1Index[updateStmt], aEntry.iMtmData1);

  1061 	BindIntL(iStatement[updateStmt], iMtmData2Index[updateStmt], aEntry.iMtmData2);

  1062 	BindIntL(iStatement[updateStmt], iMtmData3Index[updateStmt], aEntry.iMtmData3);

  1063 	BindIntL(iStatement[updateStmt], iServiceIdIndex[updateStmt], serviceId);

  1064 	BindIntL(iStatement[updateStmt], iMtmIdIndex[updateStmt], aEntry.iMtm.iUid);

  1065 	BindTextL(iStatement[updateStmt], iDescriptionIndex[updateStmt],aEntry.iDescription);

  1066 	BindTextL(iStatement[updateStmt], iDetailsIndex[updateStmt],aEntry.iDetails);

  1067 

  1068 	//Execute the prepared SQL statement.

  1069 	err = iStatement[updateStmt].Exec();

  1070 	if(err < 0)

  1071 		{

  1072 		User::Leave(err);

  1073 		}

  1074 	iStatement[updateStmt].Close();

  1075 	CleanupStack::PopAndDestroy(); //queryBuf

  1076 	}

  1077 

  1078 

  1079 

  1080 

  1081 /**

  1082  * DeleteEntryL()

  1083  * @param TMsvId: Entry Id to be deleted.

  1084  *

  1085  * The function deletes an entry with the passed Id. The function

  1086  * may leave due to database error while execution. The function

  1087  * does not leave if the entry does not exist.

  1088  *

  1089  * **WARNING** The function does NOT ensure that if a parent entry

  1090  * is deleted all its child entries are also deleted.

  1091  */

  1092 void CMsvDBAdapter::DeleteEntryL(TMsvId aEntryId)

  1093 	{

  1094 	_LIT8(KDeleteEntryQuery1, "DELETE FROM DB");

  1095 	_LIT8(KDeleteEntryQuery2, ".IndexEntry WHERE id = ");

  1096 		

  1097 	//Get the driveId and unmask the TMsvId supplied.

  1098 	TInt driveId = GetDriveId(aEntryId);

  1099 	aEntryId = UnmaskTMsvId(aEntryId);

  1100 	

  1101 	RBuf8 queryBuf;

  1102 	CleanupClosePushL(queryBuf);

  1103 	queryBuf.CreateL(100);	

  1104 	queryBuf.Append(KDeleteEntryQuery1);

  1105 	queryBuf.AppendNum(driveId);

  1106 	queryBuf.Append(KDeleteEntryQuery2);

  1107 	queryBuf.AppendNum(aEntryId);

  1108 	queryBuf.Append(KDelimiter);

  1109 	

  1110 	TInt err = iDatabase.Exec(queryBuf);

  1111 	CleanupStack::PopAndDestroy();

  1112 	if(err < 0)

  1113 		{		

  1114 		User::Leave(err);

  1115 		}

  1116 	else if(!err)

  1117 		{

  1118 		User::Leave(KErrNotFound);			

  1119 		}	

  1120 	}

  1121 

  1122 

  1123 

  1124 

  1125 /**

  1126  * DeleteEntryL()

  1127  * @param const CMsvEntrySelection&: Entry Id list to be deleted.

  1128  * @return None.

  1129  * 

  1130  * The function deletes all entries mentioned in the passed Id list.

  1131  * The function may leave due to database error while execution or

  1132  * if an entry does not exist.

  1133  *

  1134  * **WARNING** The function does NOT ensure that if a parent entry