Mercurial Mercurial > oss > FCL > sf > os > persistentdata / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
persistentstorage/sql/TEST/t_sqlperformance.cpp
changeset 55 44f437012c90
parent 31 ba1c4f4a893f
equal deleted inserted replaced
51:7d4490026038 55:44f437012c90 
    27 ///////////////////////////////////////////////////////////////////////////////////////
 
    27 ///////////////////////////////////////////////////////////////////////////////////////
 
    28 
    28 
    29 RTest TheTest(_L("t_sqlperformance test"));
 
    29 RTest TheTest(_L("t_sqlperformance test"));
 
    30 RFs   TheFs;
 
    30 RFs   TheFs;
 
    31 TBuf<200> TheTestTitle;
 
    31 TBuf<200> TheTestTitle;
 
       
    32 TBuf<250> TheLogLine;
 
       
    33 TBuf8<250> TheLogLine8;
 
    32 TCmdLineParams TheCmdLineParams;
 
    34 TCmdLineParams TheCmdLineParams;
 
    33 TBuf8<200> TheSqlConfigString;
 
    35 TBuf8<200> TheSqlConfigString;
 
    34 
    36 
    35 _LIT(KUtf8,  "UTF8 ");
 
    37 _LIT(KUtf8,  "UTF8 ");
 
    36 _LIT(KUtf16, "UTF16");
 
    38 _LIT(KUtf16, "UTF16");
 
    39 TFileName TheNonSecureDbName;
 
    41 TFileName TheNonSecureDbName;
 
    40 TFileName TheNonSecureDbName2;
 
    42 TFileName TheNonSecureDbName2;
 
    41 TFileName TheNonSecureTmpDbName;
 
    43 TFileName TheNonSecureTmpDbName;
 
    42 TFileName TheSglRecDbFileName;
 
    44 TFileName TheSglRecDbFileName;
 
    43 
    45 
    44 _LIT(KSqlServerPrivateDir, "\\private\\10281e17\\");
 
    46 //_LIT(KSqlServerPrivateDir, "\\private\\10281e17\\");
 
    45 
    47 
    46 _LIT(KCreateDbScript, "z:\\test\\contacts_schema_to_vendors.sql");
 
    48 _LIT(KCreateDbScript, "z:\\test\\contacts_schema_to_vendors.sql");
 
    47 _LIT(KFillDbScript, "z:\\test\\add_simple_contacts.sql");
 
    49 _LIT(KFillDbScript, "z:\\test\\add_simple_contacts.sql");
 
    48 
    50 
    49 _LIT8(KCommitStr8, "COMMIT;");
 
    51 _LIT8(KCommitStr8, "COMMIT;");
 
    81 _LIT(KPrmName3, ":V3");	
    83 _LIT(KPrmName3, ":V3");	
    82 _LIT(KPrmName4, ":ID");	
    84 _LIT(KPrmName4, ":ID");	
    83 
    85 
    84 const TInt KTestTecordCount = 1000;
 
    86 const TInt KTestTecordCount = 1000;
 
    85 	
    87 	
       
    88 RFile TheLogFile; 
       
    89 
    86 ///////////////////////////////////////////////////////////////////////////////////////
 
    90 ///////////////////////////////////////////////////////////////////////////////////////
 
    87 
    91 
    88 void TestEnvDestroy()
 
    92 void TestEnvDestroy()
 
    89 	{
 
    93 	{
 
       
    94 	if(TheCmdLineParams.iLogFileName.Length() > 0)
 
       
    95 		{
 
       
    96 		(void)TheLogFile.Flush();
 
       
    97 		TheLogFile.Close();
 
       
    98 		}
 
    90 	(void)RSqlDatabase::Delete(TheNonSecureTmpDbName);
 
    99 	(void)RSqlDatabase::Delete(TheNonSecureTmpDbName);
 
    91 	(void)RSqlDatabase::Delete(TheNonSecureDbName2);
 
   100 	(void)RSqlDatabase::Delete(TheNonSecureDbName2);
 
    92 	(void)RSqlDatabase::Delete(TheNonSecureDbName);
 
   101 	(void)RSqlDatabase::Delete(TheNonSecureDbName);
 
    93 	(void)RSqlDatabase::Delete(TheSecureDbName);
 
   102 	(void)RSqlDatabase::Delete(TheSecureDbName);
 
    94 	TheFs.Close();
 
   103 	TheFs.Close();
 
   125 	TInt err = TheFs.Connect();
 
   134 	TInt err = TheFs.Connect();
 
   126 	TEST2(err, KErrNone);
 
   135 	TEST2(err, KErrNone);
 
   127 
   136 
   128 	err = TheFs.MkDir(TheNonSecureDbName);
 
   137 	err = TheFs.MkDir(TheNonSecureDbName);
 
   129 	TEST(err == KErrNone || err == KErrAlreadyExists);
 
   138 	TEST(err == KErrNone || err == KErrAlreadyExists);
 
       
   139 	
       
   140 	if(TheCmdLineParams.iLogFileName.Length() > 0)
 
       
   141 		{
 
       
   142 		err = TheLogFile.Replace(TheFs, TheCmdLineParams.iLogFileName, EFileRead | EFileWrite);
 
       
   143 		TEST2(err, KErrNone);
 
       
   144 		LogConfig(TheLogFile, TheCmdLineParams);
 
       
   145 		}
 
   130 	}
 
   146 	}
 
   131 
   147 
   132 //Reads a SQL file and returns the file content as HBUFC string.
 
   148 //Reads a SQL file and returns the file content as HBUFC string.
 
   133 //The caller is responsible for destroying the returned HBUFC object.
 
   149 //The caller is responsible for destroying the returned HBUFC object.
 
   134 template <class HBUFC> HBUFC* ReadSqlScript(const TDesC& aSqlFileName)
 
   150 template <class HBUFC> HBUFC* ReadSqlScript(const TDesC& aSqlFileName)
 
   175 	}
 
   191 	}
 
   176 //Explicit GetNextTrans() template instantiations.
 
   192 //Explicit GetNextTrans() template instantiations.
 
   177 template TPtrC8 GetNextTrans<TPtrC8, TDesC8>(TPtrC8&, const TDesC8&);
 
   193 template TPtrC8 GetNextTrans<TPtrC8, TDesC8>(TPtrC8&, const TDesC8&);
 
   178 template TPtrC16 GetNextTrans<TPtrC16, TDesC16>(TPtrC16&, const TDesC16&);
 
   194 template TPtrC16 GetNextTrans<TPtrC16, TDesC16>(TPtrC16&, const TDesC16&);
 
   179 
   195 
   180 //Prints aTicks parameter (converted to ms)
 
   196 //Prints the test case title and execution time in microseconds
 
   181 void PrintStats(TUint32 aStartTicks, TUint32 aEndTicks)
 
   197 void PrintStats(TUint32 aStartTicks, TUint32 aEndTicks)
 
   182 	{
 
   198 	{
 
   183 	static TInt freq = 0;
 
   199 	static TInt freq = 0;
 
   184 	if(freq == 0)
 
   200 	if(freq == 0)
 
   185 		{
 
   201 		{
 
   190 		{
 
   206 		{
 
   191 		diffTicks = KMaxTUint32 + diffTicks + 1;
 
   207 		diffTicks = KMaxTUint32 + diffTicks + 1;
 
   192 		}
 
   208 		}
 
   193 	const TInt KMicroSecIn1Sec = 1000000;
 
   209 	const TInt KMicroSecIn1Sec = 1000000;
 
   194 	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;
 
   210 	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;
 
   195 	TheTest.Printf(_L("####Execution time: %d ms\r\n"), us / 1000);
 
   211 	TheTest.Printf(_L("%S: %d us\r\n"), &TheTestTitle, us);
 
   196 	}
 
   212 	if(TheCmdLineParams.iLogFileName.Length() > 0)
 
   197 	
   213 		{
 
       
   214 		TheLogLine.Format(_L("%S¬%d¬us\r\n"), &TheTestTitle, us);
 
       
   215 		TheLogLine8.Copy(TheLogLine);
 
       
   216 		(void)TheLogFile.Write(TheLogLine8);
 
       
   217 		}
 
       
   218 	}
 
       
   219 
       
   220 /*
 
   198 void PrintFileSize(const TDesC& aFileName)
 
   221 void PrintFileSize(const TDesC& aFileName)
 
   199 	{
 
   222 	{
 
   200 	TParse parse;
 
   223 	TParse parse;
 
   201 	parse.Set(aFileName, &KSqlServerPrivateDir(), 0);
 
   224 	parse.Set(aFileName, &KSqlServerPrivateDir(), 0);
 
   202 	RFile file;
 
   225 	RFile file;
 
   206 	err = file.Size(size);
 
   229 	err = file.Size(size);
 
   207 	TEST2(err, KErrNone);
 
   230 	TEST2(err, KErrNone);
 
   208 	TheTest.Printf(_L("####FileSize: %d\r\n"), size);
 
   231 	TheTest.Printf(_L("####FileSize: %d\r\n"), size);
 
   209 	file.Close();
 
   232 	file.Close();
 
   210 	}
 
   233 	}
 
       
   234 */
 
   211 
   235 
   212 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   236 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   213 ///////     SQL SERVER performance tests
 
   237 ///////     SQL SERVER performance tests
 
   214 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   238 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   215 	
   239 	
   312 ///////////////////////////////////////////////////////////////////////////////////////
 
   336 ///////////////////////////////////////////////////////////////////////////////////////
 
   313 
   337 
   314 //"INSERT" test function
 
   338 //"INSERT" test function
 
   315 template <class HBUFC, class PTRC, class DESC, TDbType TYPE> void InsertTest(const TDesC& aDbFileName, const DESC& aCommitStr)
 
   339 template <class HBUFC, class PTRC, class DESC, TDbType TYPE> void InsertTest(const TDesC& aDbFileName, const DESC& aCommitStr)
 
   316 	{
 
   340 	{
 
   317 	TheTest.Printf(_L("\"Insert\" test\r\n"));
 
       
   318 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   341 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   319 	ExecuteSqlScript<HBUFC, PTRC, DESC>(db, KFillDbScript, aCommitStr);
 
   342 	ExecuteSqlScript<HBUFC, PTRC, DESC>(db, KFillDbScript, aCommitStr);
 
   320 	db.Close();	
   343 	db.Close();	
   321 	}
 
   344 	}
 
   322 //Explicit InsertTest() template instantiations.
 
   345 //Explicit InsertTest() template instantiations.
 
   326 template void InsertTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   349 template void InsertTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   327 
   350 
   328 //"UPDATE" test function (parametrized update)
 
   351 //"UPDATE" test function (parametrized update)
 
   329 template <class DESC, TDbType TYPE> void UpdateTest(const TDesC& aDbFileName, const DESC& aUpdateSql)
 
   352 template <class DESC, TDbType TYPE> void UpdateTest(const TDesC& aDbFileName, const DESC& aUpdateSql)
 
   330 	{
 
   353 	{
 
   331 	TheTest.Printf(_L("\"Update (parametrized)\" test\r\n"));
 
       
   332 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   354 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   333 	RSqlStatement stmt;
 
   355 	RSqlStatement stmt;
 
   334 	TInt err = stmt.Prepare(db, aUpdateSql);
 
   356 	TInt err = stmt.Prepare(db, aUpdateSql);
 
   335 	TEST2(err, KErrNone);
 
   357 	TEST2(err, KErrNone);
 
   336 	
   358 	
   378 template void UpdateTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   400 template void UpdateTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   379 
   401 
   380 //"UPDATE" test function (without parameters) - SQL server
 
   402 //"UPDATE" test function (without parameters) - SQL server
 
   381 template <class BUF, class DESC, TDbType TYPE> void UpdateWPTest(const TDesC& aDbFileName, const DESC& aUpdateSql)
 
   403 template <class BUF, class DESC, TDbType TYPE> void UpdateWPTest(const TDesC& aDbFileName, const DESC& aUpdateSql)
 
   382 	{
 
   404 	{
 
   383 	TheTest.Printf(_L("\"Update (without parameters)\" test\r\n"));
 
       
   384 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   405 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   385 	TBuf<200> fmtstr;
 
   406 	TBuf<200> fmtstr;
 
   386 	fmtstr.Copy(aUpdateSql);
 
   407 	fmtstr.Copy(aUpdateSql);
 
   387 	
   408 	
   388 	TUint32 start = User::FastCounter();
 
   409 	TUint32 start = User::FastCounter();
 
   396 		TEST(err > 0);	
   417 		TEST(err > 0);	
   397 		}
 
   418 		}
 
   398 	TUint32 end = User::FastCounter();
 
   419 	TUint32 end = User::FastCounter();
 
   399 	PrintStats(start, end);
 
   420 	PrintStats(start, end);
 
   400 	db.Close();
 
   421 	db.Close();
 
   401 	PrintFileSize(aDbFileName);
 
   422 	//PrintFileSize(aDbFileName);
 
   402 	}
 
   423 	}
 
   403 //Explicit UpdateWPTest() template instantiations.
 
   424 //Explicit UpdateWPTest() template instantiations.
 
   404 template void UpdateWPTest<TBuf8<200>, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&);
 
   425 template void UpdateWPTest<TBuf8<200>, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&);
 
   405 template void UpdateWPTest<TBuf8<200>, TDesC8, ESecureDb>(const TDesC&, const TDesC8&);
 
   426 template void UpdateWPTest<TBuf8<200>, TDesC8, ESecureDb>(const TDesC&, const TDesC8&);
 
   406 template void UpdateWPTest<TBuf16<200>, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&);
 
   427 template void UpdateWPTest<TBuf16<200>, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&);
 
   407 template void UpdateWPTest<TBuf16<200>, TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   428 template void UpdateWPTest<TBuf16<200>, TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   408 
   429 
   409 //"SELECT" test function
 
   430 //"SELECT" test function
 
   410 template <class DESC, TDbType TYPE> void SelectTest(const TDesC& aDbFileName, const DESC& aSelectSql)
 
   431 template <class DESC, TDbType TYPE> void SelectTest(const TDesC& aDbFileName, const DESC& aSelectSql)
 
   411 	{
 
   432 	{
 
   412 	TheTest.Printf(_L("\"Select\" test\r\n"));
 
       
   413 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   433 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   414 	RSqlStatement stmt;
 
   434 	RSqlStatement stmt;
 
   415 	TInt err = stmt.Prepare(db, aSelectSql);
 
   435 	TInt err = stmt.Prepare(db, aSelectSql);
 
   416 	TEST2(err, KErrNone);
 
   436 	TEST2(err, KErrNone);
 
   417 	TUint32 start = User::FastCounter();
 
   437 	TUint32 start = User::FastCounter();
 
   441 template void SelectTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   461 template void SelectTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&);
 
   442 
   462 
   443 //"DELETE" test function
 
   463 //"DELETE" test function
 
   444 template <class DESC, TDbType TYPE> void DeleteTest(const TDesC& aDbFileName, const DESC& aDeleteSql)
 
   464 template <class DESC, TDbType TYPE> void DeleteTest(const TDesC& aDbFileName, const DESC& aDeleteSql)
 
   445 	{
 
   465 	{
 
   446 	TheTest.Printf(_L("\"Delete\" test\r\n"));
 
       
   447 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   466 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);
 
   448 	TUint32 start = User::FastCounter();
 
   467 	TUint32 start = User::FastCounter();
 
   449 	TInt err = db.Exec(aDeleteSql);
 
   468 	TInt err = db.Exec(aDeleteSql);
 
   450 	TEST(err > 0);	
   469 	TEST(err > 0);	
   451 	TUint32 end = User::FastCounter();
 
   470 	TUint32 end = User::FastCounter();
 
   468 	CFileMan* fm = NULL;
 
   487 	CFileMan* fm = NULL;
 
   469 	TRAPD(err, fm = CFileMan::NewL(TheFs));
 
   488 	TRAPD(err, fm = CFileMan::NewL(TheFs));
 
   470 	TEST2(err, KErrNone);
 
   489 	TEST2(err, KErrNone);
 
   471 	
   490 	
   472 	TDbHelper<TYPE>::Create(aDbFileName);
 
   491 	TDbHelper<TYPE>::Create(aDbFileName);
 
       
   492 	TInt titleLen = TheTestTitle.Length(); 
       
   493 	TheTestTitle.Append(_L(", insert"));
 
   473 	InsertTest<HBUFC, PTRC, DESC, TYPE>(aDbFileName, aCommitStr);
 
   494 	InsertTest<HBUFC, PTRC, DESC, TYPE>(aDbFileName, aCommitStr);
 
   474 	PrintFileSize(aDbFileName);
 
   495 	//PrintFileSize(aDbFileName);
 
   475 	(void)fm->Copy(aDbFileName, TheNonSecureTmpDbName);
 
   496 	(void)fm->Copy(aDbFileName, TheNonSecureTmpDbName);
 
   476 	
   497 	
       
   498 	TheTestTitle.Replace(titleLen, 8, _L(", update"));
 
   477 	UpdateTest<DESC, TYPE>(aDbFileName, aUpdateSql);
 
   499 	UpdateTest<DESC, TYPE>(aDbFileName, aUpdateSql);
 
   478 	PrintFileSize(aDbFileName);
 
   500 	//PrintFileSize(aDbFileName);
 
   479 	SelectTest<DESC, TYPE>(aDbFileName, aSelectSql);
 
   501 	SelectTest<DESC, TYPE>(aDbFileName, aSelectSql);
 
   480 	
   502 	
       
   503 	TheTestTitle.Replace(titleLen, 8, _L(", delete"));
 
   481 	DeleteTest<DESC, TYPE>(aDbFileName, aDeleteSql);
 
   504 	DeleteTest<DESC, TYPE>(aDbFileName, aDeleteSql);
 
   482 	PrintFileSize(aDbFileName);
 
   505 	//PrintFileSize(aDbFileName);
 
   483 	
   506 	
   484 	(void)fm->Copy(TheNonSecureTmpDbName, aDbFileName);
 
   507 	(void)fm->Copy(TheNonSecureTmpDbName, aDbFileName);
 
   485 	(void)fm->Delete(TheNonSecureTmpDbName);
 
   508 	(void)fm->Delete(TheNonSecureTmpDbName);
 
   486 	delete fm;
 
   509 	delete fm;
 
   487 	}
 
   510 	}
 
   612 template <class HBUFC, class PTRC, class DESC> void InsertTest2(sqlite3* aDbHandle, const TDesC& aScriptFileName, const DESC& aCommitStr);
 
   635 template <class HBUFC, class PTRC, class DESC> void InsertTest2(sqlite3* aDbHandle, const TDesC& aScriptFileName, const DESC& aCommitStr);
 
   613 
   636 
   614 //Explicit InsertTest2() template specialization for UTF8 encoded SQL strings
 
   637 //Explicit InsertTest2() template specialization for UTF8 encoded SQL strings
 
   615 template <> void InsertTest2<HBufC8, TPtrC8, TDesC8>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC8& aCommitStr)
 
   638 template <> void InsertTest2<HBufC8, TPtrC8, TDesC8>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC8& aCommitStr)
 
   616 	{
 
   639 	{
 
   617 	TheTest.Printf(_L("\"Insert\" test\r\n"));
 
       
   618 	HBufC8* fillDbScript = ReadSqlScript<HBufC8>(aScriptFileName);
 
   640 	HBufC8* fillDbScript = ReadSqlScript<HBufC8>(aScriptFileName);
 
   619 	TUint32 start = User::FastCounter();
 
   641 	TUint32 start = User::FastCounter();
 
   620 	TPtrC8 ptr(fillDbScript->Des());
 
   642 	TPtrC8 ptr(fillDbScript->Des());
 
   621 	TPtrC8 sql(GetNextTrans<TPtrC8, TDesC8>(ptr, aCommitStr));
 
   643 	TPtrC8 sql(GetNextTrans<TPtrC8, TDesC8>(ptr, aCommitStr));
 
   622 	while(sql.Length() > 0)
 
   644 	while(sql.Length() > 0)
 
   633 	}
 
   655 	}
 
   634 
   656 
   635 //Explicit InsertTest2() template specialization for UTF16 encoded SQL strings
 
   657 //Explicit InsertTest2() template specialization for UTF16 encoded SQL strings
 
   636 template <> void InsertTest2<HBufC16, TPtrC16, TDesC16>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC16& aCommitStr)
 
   658 template <> void InsertTest2<HBufC16, TPtrC16, TDesC16>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC16& aCommitStr)
 
   637 	{
 
   659 	{
 
   638 	TheTest.Printf(_L("\"Insert\" test\r\n"));
 
       
   639 	HBufC16* fillDbScript = ReadSqlScript<HBufC16>(aScriptFileName);
 
   660 	HBufC16* fillDbScript = ReadSqlScript<HBufC16>(aScriptFileName);
 
   640 	TUint32 start = User::FastCounter();
 
   661 	TUint32 start = User::FastCounter();
 
   641 	TPtrC16 ptr(fillDbScript->Des());
 
   662 	TPtrC16 ptr(fillDbScript->Des());
 
   642 	TPtrC16 sql(GetNextTrans<TPtrC16, TDesC16>(ptr, aCommitStr));
 
   663 	TPtrC16 sql(GetNextTrans<TPtrC16, TDesC16>(ptr, aCommitStr));
 
   643 	while(sql != KNullDesC16)
 
   664 	while(sql != KNullDesC16)
 
   677 template <class HBUFC, class DESC> void UpdateTest2(sqlite3* aDbHandle, const DESC& aUpdateSql);
 
   698 template <class HBUFC, class DESC> void UpdateTest2(sqlite3* aDbHandle, const DESC& aUpdateSql);
 
   678 
   699 
   679 //Explicit UpdateTest2() template specialization for UTF8 encoded SQL strings
 
   700 //Explicit UpdateTest2() template specialization for UTF8 encoded SQL strings
 
   680 template <> void UpdateTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aUpdateSql)
 
   701 template <> void UpdateTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aUpdateSql)
 
   681 	{
 
   702 	{
 
   682 	TheTest.Printf(_L("\"Update\" test\r\n"));
 
       
   683 	HBufC8* sql = HBufC8::New(aUpdateSql.Length() + 1);
 
   703 	HBufC8* sql = HBufC8::New(aUpdateSql.Length() + 1);
 
   684 	TEST(sql != NULL);
 
   704 	TEST(sql != NULL);
 
   685 	sql->Des().Copy(aUpdateSql);
 
   705 	sql->Des().Copy(aUpdateSql);
 
   686 	sql->Des().Append(TChar(0));
 
   706 	sql->Des().Append(TChar(0));
 
   687 
   707 
   736 	}
 
   756 	}
 
   737 
   757 
   738 //Explicit UpdateTest2() template specialization for UTF16 encoded SQL strings
 
   758 //Explicit UpdateTest2() template specialization for UTF16 encoded SQL strings
 
   739 template <> void UpdateTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aUpdateSql)
 
   759 template <> void UpdateTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aUpdateSql)
 
   740 	{
 
   760 	{
 
   741 	TheTest.Printf(_L("\"Update\" test\r\n"));
 
       
   742 	HBufC16* sql = HBufC16::New(aUpdateSql.Length() + 1);
 
   761 	HBufC16* sql = HBufC16::New(aUpdateSql.Length() + 1);
 
   743 	TEST(sql != NULL);
 
   762 	TEST(sql != NULL);
 
   744 	sql->Des().Copy(aUpdateSql);
 
   763 	sql->Des().Copy(aUpdateSql);
 
   745 	sql->Des().Append(TChar(0));
 
   764 	sql->Des().Append(TChar(0));
 
   746 
   765 
   798 template <class DESC> void UpdateWPTest2(const TDesC& aDbName, const DESC& aUpdateSql);
 
   817 template <class DESC> void UpdateWPTest2(const TDesC& aDbName, const DESC& aUpdateSql);
 
   799 
   818 
   800 //Explicit UpdateWPTest2() template specialization for UTF8 encoded SQL strings
 
   819 //Explicit UpdateWPTest2() template specialization for UTF8 encoded SQL strings
 
   801 template <> void UpdateWPTest2<TDesC8>(const TDesC& aDbName, const TDesC8& aUpdateSql)
 
   820 template <> void UpdateWPTest2<TDesC8>(const TDesC& aDbName, const TDesC8& aUpdateSql)
 
   802 	{
 
   821 	{
 
   803 	TheTest.Printf(_L("\"Update (without parameters)\" test\r\n"));
 
       
   804 	TBuf<200> fmtstr;
 
   822 	TBuf<200> fmtstr;
 
   805 	fmtstr.Copy(aUpdateSql);
 
   823 	fmtstr.Copy(aUpdateSql);
 
   806 
   824 
   807 	sqlite3SymbianLibInit();
 
   825 	sqlite3SymbianLibInit();
 
   808 	sqlite3* dbHandle = TDbHelper2<TCmdLineParams::EDbUtf8>::Open(aDbName);
 
   826 	sqlite3* dbHandle = TDbHelper2<TCmdLineParams::EDbUtf8>::Open(aDbName);
 
   828 	}
 
   846 	}
 
   829 
   847 
   830 //Explicit UpdateWPTest2() template specialization for UTF16 encoded SQL strings
 
   848 //Explicit UpdateWPTest2() template specialization for UTF16 encoded SQL strings
 
   831 template <> void UpdateWPTest2<TDesC16>(const TDesC& aDbName, const TDesC16& aUpdateSql)
 
   849 template <> void UpdateWPTest2<TDesC16>(const TDesC& aDbName, const TDesC16& aUpdateSql)
 
   832 	{
 
   850 	{
 
   833 	TheTest.Printf(_L("\"Update (without parameters)\" test\r\n"));
 
       
   834 
       
   835 	sqlite3SymbianLibInit();
 
   851 	sqlite3SymbianLibInit();
 
   836 	sqlite3* dbHandle = TDbHelper2<TCmdLineParams::EDbUtf16>::Open(aDbName);
 
   852 	sqlite3* dbHandle = TDbHelper2<TCmdLineParams::EDbUtf16>::Open(aDbName);
 
   837 	
   853 	
   838 	TUint32 start = User::FastCounter();
 
   854 	TUint32 start = User::FastCounter();
 
   839 	for(TInt id=1;id<=KTestTecordCount;++id)
 
   855 	for(TInt id=1;id<=KTestTecordCount;++id)
 
   870 template <class HBUFC, class DESC> void SelectTest2(sqlite3* aDbHandle, const DESC& aSelectSql);
 
   886 template <class HBUFC, class DESC> void SelectTest2(sqlite3* aDbHandle, const DESC& aSelectSql);
 
   871 
   887 
   872 //Explicit SelectTest2() template specialization for UTF8 encoded SQL strings
 
   888 //Explicit SelectTest2() template specialization for UTF8 encoded SQL strings
 
   873 template <> void SelectTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aSelectSql)
 
   889 template <> void SelectTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aSelectSql)
 
   874 	{
 
   890 	{
 
   875 	TheTest.Printf(_L("\"Select\" test\r\n"));
 
       
   876 	HBufC8* sql = HBufC8::New(aSelectSql.Length() + 1);
 
   891 	HBufC8* sql = HBufC8::New(aSelectSql.Length() + 1);
 
   877 	TEST(sql != NULL);
 
   892 	TEST(sql != NULL);
 
   878 	sql->Des().Copy(aSelectSql);
 
   893 	sql->Des().Copy(aSelectSql);
 
   879 	sql->Des().Append(TChar(0));
 
   894 	sql->Des().Append(TChar(0));
 
   880 
   895 
   906 	}
 
   921 	}
 
   907 
   922 
   908 //Explicit SelectTest2() template specialization for UTF16 encoded SQL strings
 
   923 //Explicit SelectTest2() template specialization for UTF16 encoded SQL strings
 
   909 template <> void SelectTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aSelectSql)
 
   924 template <> void SelectTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aSelectSql)
 
   910 	{
 
   925 	{
 
   911 	TheTest.Printf(_L("\"Select\" test\r\n"));
 
       
   912 	HBufC16* sql = HBufC16::New(aSelectSql.Length() + 1);
 
   926 	HBufC16* sql = HBufC16::New(aSelectSql.Length() + 1);
 
   913 	TEST(sql != NULL);
 
   927 	TEST(sql != NULL);
 
   914 	sql->Des().Copy(aSelectSql);
 
   928 	sql->Des().Copy(aSelectSql);
 
   915 	sql->Des().Append(TChar(0));
 
   929 	sql->Des().Append(TChar(0));
 
   916 
   930 
   944 template <class HBUFC, class DESC> void DeleteTest2(sqlite3* aDbHandle, const DESC& aDeleteSql);
 
   958 template <class HBUFC, class DESC> void DeleteTest2(sqlite3* aDbHandle, const DESC& aDeleteSql);
 
   945 
   959 
   946 //Explicit DeleteTest2() template specialization for UTF8 encoded SQL strings
 
   960 //Explicit DeleteTest2() template specialization for UTF8 encoded SQL strings
 
   947 template <> void DeleteTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aDeleteSql)
 
   961 template <> void DeleteTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aDeleteSql)
 
   948 	{
 
   962 	{
 
   949 	TheTest.Printf(_L("\"Delete\" test\r\n"));
 
       
   950 	HBufC8* sql = HBufC8::New(aDeleteSql.Length() + 1);
 
   963 	HBufC8* sql = HBufC8::New(aDeleteSql.Length() + 1);
 
   951 	TEST(sql != NULL);
 
   964 	TEST(sql != NULL);
 
   952 	sql->Des().Copy(aDeleteSql);
 
   965 	sql->Des().Copy(aDeleteSql);
 
   953 	sql->Des().Append(TChar(0));
 
   966 	sql->Des().Append(TChar(0));
 
   954 	TUint32 start = User::FastCounter();
 
   967 	TUint32 start = User::FastCounter();
 
   960 	}
 
   973 	}
 
   961 
   974 
   962 //Explicit DeleteTest2() template specialization for UTF16 encoded SQL strings
 
   975 //Explicit DeleteTest2() template specialization for UTF16 encoded SQL strings
 
   963 template <> void DeleteTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aDeleteSql)
 
   976 template <> void DeleteTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aDeleteSql)
 
   964 	{
 
   977 	{
 
   965 	TheTest.Printf(_L("\"Delete\" test\r\n"));
 
       
   966 	HBufC16* sql = HBufC16::New(aDeleteSql.Length() + 1);
 
   978 	HBufC16* sql = HBufC16::New(aDeleteSql.Length() + 1);
 
   967 	TEST(sql != NULL);
 
   979 	TEST(sql != NULL);
 
   968 	sql->Des().Copy(aDeleteSql);
 
   980 	sql->Des().Copy(aDeleteSql);
 
   969 	sql->Des().Append(TChar(0));
 
   981 	sql->Des().Append(TChar(0));
 
   970 	TUint32 start = User::FastCounter();
 
   982 	TUint32 start = User::FastCounter();
 
  1002 	
  1014 	
  1003 	sqlite3SymbianLibInit();
 
  1015 	sqlite3SymbianLibInit();
 
  1004 	TDbHelper2<TYPE>::Create(aDbFileName);
 
  1016 	TDbHelper2<TYPE>::Create(aDbFileName);
 
  1005 	
  1017 	
  1006 	sqlite3* dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
  1018 	sqlite3* dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
       
  1019 	TInt titleLen = TheTestTitle.Length(); 
       
  1020 	TheTestTitle.Append(_L(", insert"));
 
  1007 	InsertTest2<HBUFC, PTRC, DESC>(dbHandle, KFillDbScript(), aCommitStr);
 
  1021 	InsertTest2<HBUFC, PTRC, DESC>(dbHandle, KFillDbScript(), aCommitStr);
 
  1008 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1022 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1009 	PrintFileSize(aDbFileName);
 
  1023 	//PrintFileSize(aDbFileName);
 
  1010 
  1024 
  1011 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
  1025 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
       
  1026 	TheTestTitle.Replace(titleLen, 8, _L(", update"));
 
  1012 	UpdateTest2<HBUFC, DESC>(dbHandle, aUpdateSql);
 
  1027 	UpdateTest2<HBUFC, DESC>(dbHandle, aUpdateSql);
 
  1013 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1028 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1014 
  1029 
  1015 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
  1030 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
       
  1031 	TheTestTitle.Replace(titleLen, 8, _L(", select"));
 
  1016 	SelectTest2<HBUFC, DESC>(dbHandle, aSelectSql);
 
  1032 	SelectTest2<HBUFC, DESC>(dbHandle, aSelectSql);
 
  1017 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1033 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1018 
  1034 
  1019 	(void)fm->Copy(aDbFileName, TheNonSecureTmpDbName);
 
  1035 	(void)fm->Copy(aDbFileName, TheNonSecureTmpDbName);
 
  1020 	
  1036 	
  1021 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
  1037 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);
 
       
  1038 	TheTestTitle.Replace(titleLen, 8, _L(", delete"));
 
  1022 	DeleteTest2<HBUFC, DESC>(dbHandle, aDeleteSql);
 
  1039 	DeleteTest2<HBUFC, DESC>(dbHandle, aDeleteSql);
 
  1023 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1040 	(void)sqlite3_close(dbHandle); dbHandle = NULL;
 
  1024 	PrintFileSize(aDbFileName);
 
  1041 	//PrintFileSize(aDbFileName);
 
  1025 	
  1042 	
  1026 	sqlite3SymbianLibFinalize();
 
  1043 	sqlite3SymbianLibFinalize();
 
  1027 	CloseSTDLIB();
 
  1044 	CloseSTDLIB();
 
  1028 
  1045 
  1029 	(void)fm->Copy(TheNonSecureTmpDbName, aDbFileName);
 
  1046 	(void)fm->Copy(TheNonSecureTmpDbName, aDbFileName);
 
  1238 */	
  1255 */	
  1239 void DoTests()
 
  1256 void DoTests()
 
  1240 	{
 
  1257 	{
 
  1241 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1648 SQL performance tests"));
 
  1258 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1648 SQL performance tests"));
 
  1242 	
  1259 	
  1243 	TheTest.Printf(_L("Single \"update\" test\r\n"));
 
  1260 	TheTestTitle.Copy(_L("Single update"));
 
  1244 	SingleUpdateTest();
 
  1261 	SingleUpdateTest();
 
  1245 	
  1262 	
  1246 	TheTest.Printf(_L("Single \"insert\" test\r\n"));
 
  1263 	TheTestTitle.Copy(_L("Single insert"));
 
  1247 	SingleInsertTest();
 
  1264 	SingleInsertTest();
 
  1248 	
  1265 	
  1249 	TheTest.Printf(_L("Single \"delete\" test\r\n"));
 
  1266 	TheTestTitle.Copy(_L("Single delete"));
 
  1250 	SingleDeleteTest();
 
  1267 	SingleDeleteTest();
 
  1251 	
  1268 	
  1252 	TheTestTitle.Format(_L("SERVER, UTF8 SQL strings, non-secure, encoding: \"%S\", page size: %d\r\n"), 
  1269 	TheTestTitle.Format(_L("SERVER, sql:UTF8, dbencoding:%S, non-secure"),
 
  1253 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
 
  1270 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8);
 
  1254 	TheTest.Printf(TheTestTitle);
 
       
  1255 	PerformanceTest<HBufC8, TPtrC8, TDesC8, ENonSecureDb>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1271 	PerformanceTest<HBufC8, TPtrC8, TDesC8, ENonSecureDb>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1256 
  1272 
  1257 	TheTestTitle.Format(_L("SERVER, UTF8 SQL strings, non-secure, update test (without parameters), encoding: \"%S\", page size: %d\r\n"), 
  1273 	TheTestTitle.Format(_L("SERVER, sql:UTF8, dbencoding:%S, non-secure, update without parameters"), 
  1258 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
 
  1274 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8);
 
  1259 	TheTest.Printf(TheTestTitle);
 
       
  1260 	UpdateWPTest<TBuf8<200>, TDesC8, ENonSecureDb>(TheNonSecureDbName, KUpdateSql2_8());
 
  1275 	UpdateWPTest<TBuf8<200>, TDesC8, ENonSecureDb>(TheNonSecureDbName, KUpdateSql2_8());
 
  1261 
  1276 
  1262 	TheTestTitle.Format(_L("SERVER, UTF8 SQL strings, secure, encoding: \"%S\", page size: %d\r\n"), 
  1277 	TheTestTitle.Format(_L("SERVER, sql:UTF8, dbencoding:%S, secure"), 
  1263 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
 
  1278 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8);
 
  1264 	TheTest.Printf(TheTestTitle);
 
       
  1265 	PerformanceTest<HBufC8, TPtrC8, TDesC8, ESecureDb>(TheSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1279 	PerformanceTest<HBufC8, TPtrC8, TDesC8, ESecureDb>(TheSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1266 
  1280 
  1267 	TheTest.Printf(_L("SQLITE, UTF8 encoded database, UTF8 SQL strings\r\n"));
 
  1281 	TheTestTitle.Copy(_L("SQLITE, sql:UTF8, dbencoding:UTF8"));
 
  1268 	PerformanceTest2<TCmdLineParams::EDbUtf8, HBufC8, TPtrC8, TDesC8>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1282 	PerformanceTest2<TCmdLineParams::EDbUtf8, HBufC8, TPtrC8, TDesC8>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1269 
  1283 
  1270 	TheTest.Printf(_L("SQLITE, UTF8 encoded database, UTF8 SQL strings, update test (without parameters)\r\n"));
 
  1284 	TheTestTitle.Copy(_L("SQLITE, sql:UTF8, dbencoding:UTF8, update without parameters"));
 
  1271 	UpdateWPTest2<TDesC8>(TheNonSecureDbName, KUpdateSql2_8());
 
  1285 	UpdateWPTest2<TDesC8>(TheNonSecureDbName, KUpdateSql2_8());
 
  1272 
  1286 
  1273 	TheTest.Printf(_L("SQLITE, UTF16 encoded database, UTF8 SQL strings\r\n"));
 
  1287 	TheTestTitle.Copy(_L("SQLITE, sql:UTF8, dbencoding:UTF16"));
 
  1274 	PerformanceTest2<TCmdLineParams::EDbUtf16, HBufC8, TPtrC8, TDesC8>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1288 	PerformanceTest2<TCmdLineParams::EDbUtf16, HBufC8, TPtrC8, TDesC8>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8());
 
  1275 
  1289 
  1276 	TheTestTitle.Format(_L("SERVER, UTF16 SQL strings, non-secure, encoding: \"%S\", page size: %d\r\n"), 
  1290 	TheTestTitle.Format(_L("SERVER, sql:UTF16, dbencoding:%S, non-secure"), 
  1277 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
 
  1291 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8);
 
  1278 	TheTest.Printf(TheTestTitle);
 
       
  1279 	PerformanceTest<HBufC16, TPtrC16, TDesC16, ENonSecureDb>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1292 	PerformanceTest<HBufC16, TPtrC16, TDesC16, ENonSecureDb>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1280 	
  1293 	
  1281 	TheTestTitle.Format(_L("SERVER, UTF16 SQL strings, non-secure, update test (without parameters), encoding: \"%S\", page size: %d\r\n"), 
  1294 	TheTestTitle.Format(_L("SERVER, sql:UTF16, dbencoding:%S, non-secure, update without parameters"), 
  1282 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
 
  1295 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8);
 
  1283 	TheTest.Printf(TheTestTitle);
 
       
  1284 	UpdateWPTest<TBuf16<200>, TDesC16, ENonSecureDb>(TheNonSecureDbName, KUpdateSql2_16());
 
  1296 	UpdateWPTest<TBuf16<200>, TDesC16, ENonSecureDb>(TheNonSecureDbName, KUpdateSql2_16());
 
  1285 
  1297 
  1286 	TheTestTitle.Format(_L("SERVER, UTF16 SQL strings, secure, encoding: \"%S\", page size: %d\r\n"), 
  1298 	TheTestTitle.Format(_L("SERVER, sql:UTF16, dbencoding:%S, secure"), 
  1287 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
 
  1299 			TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8);
 
  1288 	TheTest.Printf(TheTestTitle);
 
       
  1289 	PerformanceTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(TheSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1300 	PerformanceTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(TheSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1290 
  1301 
  1291 	TheTest.Printf(_L("SQLITE, UTF8 encoded database, UTF16 SQL strings\r\n"));
 
  1302 	TheTestTitle.Copy(_L("SQLITE, sql:UTF16, dbencoding:UTF8"));
 
  1292 	PerformanceTest2<TCmdLineParams::EDbUtf8, HBufC16, TPtrC16, TDesC16>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1303 	PerformanceTest2<TCmdLineParams::EDbUtf8, HBufC16, TPtrC16, TDesC16>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1293 
  1304 
  1294 	TheTest.Printf(_L("SQLITE, UTF16 encoded database, UTF16 SQL strings\r\n"));
 
  1305 	TheTestTitle.Copy(_L("SQLITE, sql:UTF16, dbencoding:UTF16"));
 
  1295 	PerformanceTest2<TCmdLineParams::EDbUtf16, HBufC16, TPtrC16, TDesC16>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1306 	PerformanceTest2<TCmdLineParams::EDbUtf16, HBufC16, TPtrC16, TDesC16>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16());
 
  1296 
  1307 
  1297 	TheTest.Printf(_L("SQLITE, UTF16 encoded database, UTF16 SQL strings, update test (without parameters)\r\n"));
 
  1308 	TheTestTitle.Copy(_L("SQLITE, sql:UTF16, dbencoding:UTF16, update without parameters"));
 
  1298 	UpdateWPTest2<TDesC16>(TheNonSecureDbName, KUpdateSql2_16());
 
  1309 	UpdateWPTest2<TDesC16>(TheNonSecureDbName, KUpdateSql2_16());
 
  1299 
  1310 
  1300 	TheTest.Printf(_L("Accessing column value by index or by name\r\n"));
 
  1311 	TheTestTitle.Copy(_L("Accessing column value by index or by name"));
 
  1301 	ColumnValueAccessTest();
 
  1312 	ColumnValueAccessTest();
 
  1302 	
  1313 	
  1303 	TheTest.Printf(_L("Retrieving data from UTF8 Database using SELECT LIKE statements\r\n"));
 
  1314 	TheTestTitle.Copy(_L("Retrieving data from UTF8 Database using SELECT LIKE statements"));
 
  1304 	SelectLikeQueryPerfTest();
 
  1315 	SelectLikeQueryPerfTest();
 
  1305 
  1316 
  1306 	}
 
  1317 	}
 
  1307 
  1318 
  1308 TInt E32Main()
 
  1319 TInt E32Main()
FCL/sf/os/persistentdata