1 // Copyright (c) 2006-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 //

    15 

    16 #include <e32test.h>

    17 #include <e32math.h>

    18 #include <bautils.h>

    19 #include <hal.h>

    20 #include <stdlib.h>

    21 #include <sqldb.h>

    22 #include "SqlSrvStrings.h"

    23 #include "sqlite3.h"

    24 #include "SqliteSymbian.h"

    25 

    26 ///////////////////////////////////////////////////////////////////////////////////////

    27 

    28 RTest TheTest(_L("t_sqlperformance test"));

    29 RFs   TheFs;

    30 

    31 TBuf<200> TheTestTitle;

    32 TBuf<256> TheCmd;

    33 TParse TheParse;

    34 TBuf<8> TheDriveName;

    35 

    36 _LIT8(KDbEncodingUtf8, "encoding=UTF-8");

    37 _LIT(KDbEncodingUtf8text,  "UTF8  encoded db");

    38 _LIT(KDbEncodingUtf16text, "UTF16 encoded db");

    39 

    40 TFileName TheSecureDbName;

    41 TFileName TheNonSecureDbName;

    42 TFileName TheNonSecureDbName2;

    43 TFileName TheNonSecureTmpDbName;

    44 TFileName TheSglRecDbFileName;

    45 

    46 enum TDbEncoding

    47 	{

    48 	EDbUtf8,

    49 	EDbUtf16

    50 	};

    51 	

    52 TDbEncoding TheDbEncoding;

    53 

    54 _LIT(KSqlServerPrivateDir, "\\private\\10281e17\\");

    55 

    56 _LIT(KCreateDbScript, "z:\\test\\contacts_schema_to_vendors.sql");

    57 _LIT(KFillDbScript, "z:\\test\\add_simple_contacts.sql");

    58 

    59 _LIT8(KCommitStr8, "COMMIT;");

    60 _LIT16(KCommitStr16, "COMMIT;");

    61 

    62 _LIT8(KUpdateSql8, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME=:V1, CM_LASTNAME=:V2,CM_COMPANYNAME=:V3 WHERE PARENT_CMID=:ID");

    63 _LIT16(KUpdateSql16, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME=:V1, CM_LASTNAME=:V2,CM_COMPANYNAME=:V3 WHERE PARENT_CMID=:ID");

    64 

    65 _LIT8(KUpdateSql2_8, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME='%S%d',CM_LASTNAME='%S%d',CM_COMPANYNAME='%S%d' WHERE PARENT_CMID=%d");

    66 _LIT16(KUpdateSql2_16, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME='%S%d',CM_LASTNAME='%S%d',CM_COMPANYNAME='%S%d' WHERE PARENT_CMID=%d");

    67 

    68 _LIT8(KSelectSql8, "SELECT CM_FIRSTNAME, CM_LASTNAME, CM_COMPANYNAME FROM IDENTITYTABLE WHERE PARENT_CMID > 50");

    69 _LIT16(KSelectSql16, "SELECT CM_FIRSTNAME, CM_LASTNAME, CM_COMPANYNAME FROM IDENTITYTABLE WHERE PARENT_CMID > 50");

    70 

    71 _LIT8(KDeleteSql8, "DELETE FROM IDENTITYTABLE WHERE PARENT_CMID > 50");

    72 _LIT16(KDeleteSql16, "DELETE FROM IDENTITYTABLE WHERE PARENT_CMID > 50");

    73 

    74 extern TPtrC GetFirstSqlStmt(TPtr& aString);

    75 

    76 _LIT(KFirstName, "FirstName-");

    77 _LIT(KLastName, "LastName-");

    78 _LIT(KCompanyName, "CompanyName-");

    79 

    80 _LIT(KFirstName2, "12345678-");

    81 _LIT(KLastName2, "ABCDEFGHIJK-");

    82 _LIT(KCompanyName2, "KKKKKKKKKK10-");

    83 

    84 const char* KRawPrmName1 = ":V1";

    85 const char* KRawPrmName2 = ":V2";

    86 const char* KRawPrmName3 = ":V3";

    87 const char* KRawPrmName4 = ":ID";

    88 

    89 _LIT(KPrmName1, ":V1");	

    90 _LIT(KPrmName2, ":V2");	

    91 _LIT(KPrmName3, ":V3");	

    92 _LIT(KPrmName4, ":ID");	

    93 

    94 const TInt KTestTecordCount = 1000;

    95 	

    96 ///////////////////////////////////////////////////////////////////////////////////////

    97 

    98 void TestEnvDestroy()

    99 	{

   100 	(void)RSqlDatabase::Delete(TheNonSecureTmpDbName);

   101 	(void)RSqlDatabase::Delete(TheNonSecureDbName2);

   102 	(void)RSqlDatabase::Delete(TheNonSecureDbName);

   103 	(void)RSqlDatabase::Delete(TheSecureDbName);

   104 	TheFs.Close();

   105 	}

   106 

   107 ///////////////////////////////////////////////////////////////////////////////////////

   108 ///////////////////////////////////////////////////////////////////////////////////////

   109 //Test macros and functions

   110 void Check1(TInt aValue, TInt aLine)

   111 	{

   112 	if(!aValue)

   113 		{

   114 		TestEnvDestroy();

   115 		TheTest.Printf(_L("*** Line %d\r\n"), aLine);

   116 		TheTest(EFalse, aLine);

   117 		}

   118 	}

   119 void Check2(TInt aValue, TInt aExpected, TInt aLine)

   120 	{

   121 	if(aValue != aExpected)

   122 		{

   123 		TestEnvDestroy();

   124 		TheTest.Printf(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);

   125 		TheTest(EFalse, aLine);

   126 		}

   127 	}

   128 #define TEST(arg) ::Check1((arg), __LINE__)

   129 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

   130 

   131 ///////////////////////////////////////////////////////////////////////////////////////

   132 

   133 void TestEnvInit()

   134     {

   135 	TInt err = TheFs.Connect();

   136 	TEST2(err, KErrNone);

   137 

   138 	err = TheFs.MkDir(TheNonSecureDbName);

   139 	TEST(err == KErrNone || err == KErrAlreadyExists);

   140 	}

   141 

   142 //Reads a SQL file and returns the file content as HBUFC string.

   143 //The caller is responsible for destroying the returned HBUFC object.

   144 template <class HBUFC> HBUFC* ReadSqlScript(const TDesC& aSqlFileName)

   145 	{

   146 	RFile file;

   147 	TEST2(file.Open(TheFs, aSqlFileName, EFileRead), KErrNone);

   148 	

   149 	TInt size = 0;

   150 	TEST2(file.Size(size), KErrNone);

   151 	

   152 	HBufC8* sql = HBufC8::New(size);

   153 	TEST(sql != NULL);

   154 	

   155 	TPtr8 ptr = sql->Des();

   156 	TEST2(file.Read(ptr, size), KErrNone);

   157 

   158 	file.Close();

   159 	

   160 	HBUFC* sql2 = HBUFC::New(size);

   161 	TEST(sql2 != NULL);

   162 	sql2->Des().Copy(sql->Des());

   163 	delete sql;

   164 	

   165 	return sql2;

   166 	}

   167 //Explicit ReadSqlScript() template instantiations.

   168 template HBufC8* ReadSqlScript<HBufC8>(const TDesC&);

   169 template HBufC16* ReadSqlScript<HBufC16>(const TDesC&);

   170 

   171 //Searches for the next aCommitStr appearance in aSqlScript string and returns a PTRC object holding

   172 //the SQL strings from the beginning of aSqlScript till the aCommitStr (including it).

   173 template <class PTRC, class DESC> PTRC GetNextTrans(PTRC& aSqlScript, const DESC& aCommitStr)

   174 	{

   175 	PTRC res(NULL, 0);

   176 	TInt pos = aSqlScript.FindF(aCommitStr);

   177 	if(pos >= 0)

   178 		{

   179 		pos += aCommitStr.Length();

   180 		res.Set(aSqlScript.Left(pos));

   181 		aSqlScript.Set(aSqlScript.Mid(pos));

   182 		}

   183 	return res;

   184 	}

   185 //Explicit GetNextTrans() template instantiations.

   186 template TPtrC8 GetNextTrans<TPtrC8, TDesC8>(TPtrC8&, const TDesC8&);

   187 template TPtrC16 GetNextTrans<TPtrC16, TDesC16>(TPtrC16&, const TDesC16&);

   188 

   189 //Prints aTicks parameter (converted to ms)

   190 void PrintStats(TUint32 aStartTicks, TUint32 aEndTicks)

   191 	{

   192 	static TInt freq = 0;

   193 	if(freq == 0)

   194 		{

   195 		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);

   196 		}

   197 	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

   198 	if(diffTicks < 0)

   199 		{

   200 		diffTicks = KMaxTUint32 + diffTicks + 1;

   201 		}

   202 	const TInt KMicroSecIn1Sec = 1000000;

   203 	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

   204 	TheTest.Printf(_L("####Execution time: %d ms\r\n"), us / 1000);

   205 	}

   206 	

   207 void PrintFileSize(const TDesC& aFileName)

   208 	{

   209 	TParse parse;

   210 	parse.Set(aFileName, &KSqlServerPrivateDir(), 0);

   211 	RFile file;

   212 	TInt err = file.Open(TheFs, parse.FullName(), EFileRead);

   213 	TEST2(err, KErrNone);

   214 	TInt size = 0;

   215 	err = file.Size(size);

   216 	TEST2(err, KErrNone);

   217 	TheTest.Printf(_L("####FileSize: %d\r\n"), size);

   218 	file.Close();

   219 	}

   220 

   221 //////////////////////////////////////////////////////////////////////////////////////////////////////////////

   222 ///////     SQL SERVER performance tests

   223 //////////////////////////////////////////////////////////////////////////////////////////////////////////////

   224 	

   225 enum TDbType {ENonSecureDb, ESecureDb};

   226 

   227 //Template class offering Create() and Open() methods for creating/opening a RSqlDatabase object

   228 template <TDbType TYPE> class TDbHelper

   229 	{

   230 public:	

   231 	static void Create(const TDesC& aDbName);

   232 	static RSqlDatabase Open(const TDesC& aDbName);

   233 	};

   234 

   235 //Creates aDb database schema.

   236 void CreateDbSchema(RSqlDatabase& aDb)

   237 	{

   238 	HBufC8* createDbScript = ReadSqlScript<HBufC8>(KCreateDbScript());

   239 	TInt err = aDb.Exec(createDbScript->Des());

   240 	TEST(err >= 0);	

   241 	delete createDbScript;

   242 	}

   243 

   244 //Explicit TDbHelper class specialization for creating/opening a nonsecure RSqlDatabase object

   245 template <> class TDbHelper<ENonSecureDb>

   246 	{

   247 public:	

   248 	static void Create(const TDesC& aDbName)

   249 		{

   250 		RSqlDatabase::Delete(aDbName);

   251 		RSqlDatabase db;

   252 		TInt err = db.Create(aDbName, TheDbEncoding == EDbUtf16 ? NULL : &KDbEncodingUtf8);

   253 		TEST2(err, KErrNone);

   254 		CreateDbSchema(db);

   255 		db.Close();

   256 		}

   257 	static RSqlDatabase Open(const TDesC& aDbName)

   258 		{

   259 		RSqlDatabase db;

   260 		TInt err = db.Open(aDbName);

   261 		TEST2(err, KErrNone);

   262 		return db;

   263 		}

   264 	};

   265 

   266 //Explicit TDbHelper class specialization for creating/opening a secure RSqlDatabase object

   267 template <> class TDbHelper<ESecureDb>

   268 	{

   269 public:	

   270 	static void Create(const TDesC& aDbName)

   271 		{

   272 		RSqlDatabase::Delete(aDbName);

   273 		RSqlSecurityPolicy securityPolicy;

   274 		TInt err = securityPolicy.Create(TSecurityPolicy(TSecurityPolicy::EAlwaysPass));

   275 		TEST2(err, KErrNone);	

   276 		securityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, TSecurityPolicy(ECapabilityReadUserData, ECapabilityWriteUserData));

   277 		securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy(ECapabilityWriteUserData));

   278 		securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy(ECapabilityReadUserData));

   279 		RSqlDatabase db;

   280 		err = db.Create(aDbName, securityPolicy, TheDbEncoding == EDbUtf16 ? NULL : &KDbEncodingUtf8);

   281 		TEST2(err, KErrNone);	

   282 		securityPolicy.Close();

   283 		CreateDbSchema(db);

   284 		db.Close();

   285 		}

   286 	static RSqlDatabase Open(const TDesC& aDbName)

   287 		{

   288 		RSqlDatabase db;

   289 		TInt err = db.Open(aDbName);

   290 		TEST2(err, KErrNone);

   291 		return db;

   292 		}

   293 	};

   294 

   295 //Executes SQL script

   296 template <class HBUFC, class PTRC, class DESC> void ExecuteSqlScript(RSqlDatabase& aDb, const TDesC& aScriptFileName, const DESC& aCommitStr)

   297 	{

   298 	HBUFC* fillDbScript = ReadSqlScript<HBUFC>(aScriptFileName);

   299 	TUint32 start = User::FastCounter();

   300 	PTRC ptr(fillDbScript->Des());

   301 	PTRC sql(GetNextTrans<PTRC, DESC>(ptr, aCommitStr));

   302 	while(sql.Length() > 0)

   303 		{

   304 		TInt err = aDb.Exec(sql);

   305 		if(err == KErrNoMemory)

   306 			{

   307 			TheTest.Printf(_L("###ERROR 'Out of memory'! The test cannot be completed!\r\n"));

   308 			return;	

   309 			}

   310 		TEST(err > 0);	

   311 		sql.Set(GetNextTrans<PTRC, DESC>(ptr, aCommitStr));

   312 		}

   313 	TUint32 end = User::FastCounter();

   314 	PrintStats(start, end);

   315 	delete fillDbScript;

   316 	}

   317 //Explicit ExecuteSqlScript() template instantiations.

   318 template void ExecuteSqlScript<HBufC8, TPtrC8, TDesC8>(RSqlDatabase&, const TDesC&, const TDesC8&);

   319 template void ExecuteSqlScript<HBufC16, TPtrC16, TDesC16>(RSqlDatabase&, const TDesC&, const TDesC16&);

   320 

   321 ///////////////////////////////////////////////////////////////////////////////////////

   322 

   323 //"INSERT" test function

   324 template <class HBUFC, class PTRC, class DESC, TDbType TYPE> void InsertTest(const TDesC& aDbFileName, const DESC& aCommitStr)

   325 	{

   326 	TheTest.Printf(_L("\"Insert\" test\r\n"));

   327 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);

   328 	ExecuteSqlScript<HBUFC, PTRC, DESC>(db, KFillDbScript, aCommitStr);

   329 	db.Close();	

   330 	}

   331 //Explicit InsertTest() template instantiations.

   332 template void InsertTest<HBufC8, TPtrC8, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&);

   333 template void InsertTest<HBufC8, TPtrC8, TDesC8, ESecureDb>(const TDesC&, const TDesC8&);

   334 template void InsertTest<HBufC16, TPtrC16, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&);

   335 template void InsertTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(const TDesC&, const TDesC16&);

   336 

   337 //"UPDATE" test function (parametrized update)

   338 template <class DESC, TDbType TYPE> void UpdateTest(const TDesC& aDbFileName, const DESC& aUpdateSql)

   339 	{

   340 	TheTest.Printf(_L("\"Update (parametrized)\" test\r\n"));

   341 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);

   342 	RSqlStatement stmt;

   343 	TInt err = stmt.Prepare(db, aUpdateSql);

   344 	TEST2(err, KErrNone);

   345 	

   346 	TInt firstNamePrmIdx = stmt.ParameterIndex(KPrmName1());

   347 	TEST(firstNamePrmIdx >= 0);

   348 	TInt lastNamePrmIdx = stmt.ParameterIndex(KPrmName2());

   349 	TEST(lastNamePrmIdx >= 0);

   350 	TInt companyNamePrmIdx = stmt.ParameterIndex(KPrmName3());

   351 	TEST(companyNamePrmIdx >= 0);

   352 	TInt idIdx = stmt.ParameterIndex(KPrmName4());

   353 	TEST(idIdx >= 0);

   354 	

   355 	TUint32 start = User::FastCounter();

   356 	for(TInt id=1;id<=KTestTecordCount;++id)

   357 		{

   358 		TBuf<20> buf;

   359 		buf.Copy(KFirstName);

   360 		buf.AppendNum(id);

   361 		err = stmt.BindText(firstNamePrmIdx, buf);

   362 		TEST2(err, KErrNone);

   363 		buf.Copy(KLastName);

   364 		buf.AppendNum(id);

   365 		err = stmt.BindText(lastNamePrmIdx, buf);

   366 		TEST2(err, KErrNone);

   367 		buf.Copy(KCompanyName);

   368 		buf.AppendNum(id);

   369 		err = stmt.BindText(companyNamePrmIdx, buf);

   370 		TEST2(err, KErrNone);

   371 		err = stmt.BindInt(idIdx, id);

   372 		TEST2(err, KErrNone);

   373 		err = stmt.Exec();

   374 		TEST(err > 0);	

   375 		err = stmt.Reset();

   376 		TEST2(err, KErrNone);

   377 		}

   378 	TUint32 end = User::FastCounter();

   379 	PrintStats(start, end);

   380 	stmt.Close();

   381 	db.Close();

   382 	}

   383 //Explicit UpdateTest() template instantiations.

   384 template void UpdateTest<TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&);

   385 template void UpdateTest<TDesC8, ESecureDb>(const TDesC&, const TDesC8&);

   386 template void UpdateTest<TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&);

   387 template void UpdateTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&);

   388 

   389 //"UPDATE" test function (without parameters) - SQL server

   390 template <class BUF, class DESC, TDbType TYPE> void UpdateWPTest(const TDesC& aDbFileName, const DESC& aUpdateSql)

   391 	{

   392 	TheTest.Printf(_L("\"Update (without parameters)\" test\r\n"));

   393 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);

   394 	TBuf<200> fmtstr;

   395 	fmtstr.Copy(aUpdateSql);

   396 	

   397 	TUint32 start = User::FastCounter();

   398 	for(TInt id=1;id<=KTestTecordCount;++id)

   399 		{

   400 		TBuf<200> buf;

   401 		buf.Format(fmtstr, &KFirstName2, id, &KLastName2, id, &KCompanyName2, id, id);

   402 		BUF sql;

   403 		sql.Copy(buf);

   404 		TInt err = db.Exec(sql);

   405 		TEST(err > 0);	

   406 		}

   407 	TUint32 end = User::FastCounter();

   408 	PrintStats(start, end);

   409 	db.Close();

   410 	PrintFileSize(aDbFileName);

   411 	}

   412 //Explicit UpdateWPTest() template instantiations.

   413 template void UpdateWPTest<TBuf8<200>, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&);

   414 template void UpdateWPTest<TBuf8<200>, TDesC8, ESecureDb>(const TDesC&, const TDesC8&);

   415 template void UpdateWPTest<TBuf16<200>, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&);

   416 template void UpdateWPTest<TBuf16<200>, TDesC16, ESecureDb>(const TDesC&, const TDesC16&);

   417 

   418 //"SELECT" test function

   419 template <class DESC, TDbType TYPE> void SelectTest(const TDesC& aDbFileName, const DESC& aSelectSql)

   420 	{

   421 	TheTest.Printf(_L("\"Select\" test\r\n"));

   422 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);

   423 	RSqlStatement stmt;

   424 	TInt err = stmt.Prepare(db, aSelectSql);

   425 	TEST2(err, KErrNone);

   426 	TUint32 start = User::FastCounter();

   427 	while((err = stmt.Next()) == KSqlAtRow)

   428 		{

   429 		TBuf<20> buf;

   430 		err = stmt.ColumnText(0, buf);			

   431 		TEST2(err, KErrNone);

   432 		TEST(buf.Length() > 0);

   433 		err = stmt.ColumnText(1, buf);			

   434 		TEST2(err, KErrNone);

   435 		TEST(buf.Length() > 0);

   436 		err = stmt.ColumnText(2, buf);			

   437 		TEST2(err, KErrNone);

   438 		TEST(buf.Length() > 0);

   439 		}

   440 	TEST2(err, KSqlAtEnd);

   441 	TUint32 end = User::FastCounter();

   442 	PrintStats(start, end);

   443 	stmt.Close();

   444 	db.Close();	

   445 	}

   446 //Explicit SelectTest() template instantiations.

   447 template void SelectTest<TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&);

   448 template void SelectTest<TDesC8, ESecureDb>(const TDesC&, const TDesC8&);

   449 template void SelectTest<TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&);

   450 template void SelectTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&);

   451 

   452 //"DELETE" test function

   453 template <class DESC, TDbType TYPE> void DeleteTest(const TDesC& aDbFileName, const DESC& aDeleteSql)

   454 	{

   455 	TheTest.Printf(_L("\"Delete\" test\r\n"));

   456 	RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName);

   457 	TUint32 start = User::FastCounter();

   458 	TInt err = db.Exec(aDeleteSql);

   459 	TEST(err > 0);	

   460 	TUint32 end = User::FastCounter();

   461 	PrintStats(start, end);

   462 	db.Close();	

   463 	}

   464 //Explicit SelectTest() template instantiations.

   465 template void DeleteTest<TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&);

   466 template void DeleteTest<TDesC8, ESecureDb>(const TDesC&, const TDesC8&);

   467 template void DeleteTest<TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&);

   468 template void DeleteTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&);

   469 	

   470 //Performance test function: INSERT, UPDATE, SELECT

   471 template <class HBUFC, class PTRC, class DESC, TDbType TYPE> void PerformanceTest(const TDesC& aDbFileName,

   472 																				  const DESC& aCommitStr,

   473 																				  const DESC& aUpdateSql,

   474 																				  const DESC& aSelectSql,

   475 																				  const DESC& aDeleteSql)

   476 	{

   477 	CFileMan* fm = NULL;

   478 	TRAPD(err, fm = CFileMan::NewL(TheFs));

   479 	TEST2(err, KErrNone);

   480 	

   481 	TDbHelper<TYPE>::Create(aDbFileName);

   482 	InsertTest<HBUFC, PTRC, DESC, TYPE>(aDbFileName, aCommitStr);

   483 	PrintFileSize(aDbFileName);

   484 	(void)fm->Copy(aDbFileName, TheNonSecureTmpDbName);

   485 	

   486 	UpdateTest<DESC, TYPE>(aDbFileName, aUpdateSql);

   487 	PrintFileSize(aDbFileName);

   488 	SelectTest<DESC, TYPE>(aDbFileName, aSelectSql);

   489 	

   490 	DeleteTest<DESC, TYPE>(aDbFileName, aDeleteSql);

   491 	PrintFileSize(aDbFileName);

   492 	

   493 	(void)fm->Copy(TheNonSecureTmpDbName, aDbFileName);

   494 	(void)fm->Delete(TheNonSecureTmpDbName);

   495 	delete fm;

   496 	}

   497 //Explicit PerformanceTest() template instantiations.

   498 template void PerformanceTest<HBufC8, TPtrC8, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&);

   499 template void PerformanceTest<HBufC8, TPtrC8, TDesC8, ESecureDb>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&);

   500 template void PerformanceTest<HBufC16, TPtrC16, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&);

   501 template void PerformanceTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&);

   502 

   503 //////////////////////////////////////////////////////////////////////////////////////////////////////////////

   504 ///////     SQLITE API used directly  

   505 //////////////////////////////////////////////////////////////////////////////////////////////////////////////

   506 

   507 //Template class offering Create() and Open() methods for creating/opening a sqlite3 handle.

   508 template <TDbEncoding TYPE> class TDbHelper2

   509 	{

   510 public:	

   511 	static void Create(const TDesC& aDbName);

   512 	static sqlite3* Open(const TDesC& aDbName);

   513 	};

   514 

   515 //If error - prints error message and panics the application

   516 void PanicIfError(sqlite3* aDbHandle, TInt aErr)

   517 	{

   518   	if(aErr != SQLITE_OK && aErr != SQLITE_DONE && aErr != SQLITE_ROW)

   519   		{

   520   		if(aDbHandle)

   521   			{

   522 	  		TPtrC p((const TUint16*)sqlite3_errmsg16(aDbHandle));

   523 	  		TheTest.Printf(_L("Database err %d, msg: %S\n\n"), aErr, &p);

   524 			(void)sqlite3_close(aDbHandle);

   525   			}

   526     	TEST(0);

   527   		}

   528 	}

   529 

   530 //If error - prints error message and returns zero

   531 TInt ReportIfError(sqlite3* aDbHandle, TInt aErr)

   532 	{

   533   	if(aErr != SQLITE_OK && aErr != SQLITE_DONE && aErr != SQLITE_ROW)

   534   		{

   535   		if(aDbHandle)

   536   			{

   537 	  		TPtrC p((const TUint16*)sqlite3_errmsg16(aDbHandle));

   538 	  		TheTest.Printf(_L("Database err %d, msg: %S\n\n"), aErr, &p);

   539   			}

   540   		return ETrue;

   541   		}

   542   	return EFalse;

   543 	}

   544 

   545 //Explicit TDbHelper2 class specialization for creating/opening a database with UTF8 default encoding

   546 template <> class TDbHelper2<EDbUtf8>

   547 	{

   548 public:	

   549 	static void Create(const TDesC& aDbFileName)

   550 		{

   551 		(void)TheFs.Delete(aDbFileName);

   552 		HBufC8* dbName = HBufC8::New(aDbFileName.Length() + 1);

   553 		TEST(dbName != NULL);

   554 		dbName->Des().Copy(aDbFileName);

   555 		sqlite3* dbHandle = NULL;

   556 		TInt err = sqlite3_open((const char*)(dbName->Des().PtrZ()), &dbHandle);

   557 		delete dbName;

   558 		PanicIfError(dbHandle, err);

   559 		HBufC8* createDbScript = ReadSqlScript<HBufC8>(KCreateDbScript());

   560 		HBufC8* createDbScript2 = HBufC8::New(createDbScript->Des().Length() + 1);

   561 		TEST(createDbScript2 != NULL);

   562 		createDbScript2->Des().Copy(createDbScript->Des());

   563 		delete createDbScript;

   564 		createDbScript2->Des().Append(TChar(0));

   565 		err = sqlite3_exec(dbHandle, (const char*)createDbScript2->Des().Ptr(), NULL, 0, NULL);

   566 		PanicIfError(dbHandle, err);

   567 		delete createDbScript2;

   568 		(void)sqlite3_close(dbHandle);

   569 		}

   570 	static sqlite3* Open(const TDesC& aDbFileName)

   571 		{

   572 		HBufC8* dbName = HBufC8::New(aDbFileName.Length() + 1);

   573 		TEST(dbName != NULL);

   574 		dbName->Des().Copy(aDbFileName);

   575 		sqlite3* dbHandle = NULL;

   576 		TInt err = sqlite3_open((const char*)(dbName->Des().PtrZ()), &dbHandle);

   577 		delete dbName;

   578 		PanicIfError(dbHandle, err);

   579 		return dbHandle;

   580 		}

   581 	};

   582 

   583 //Explicit TDbHelper2 class specialization for creating/opening a database with UTF16 default encoding

   584 template <> class TDbHelper2<EDbUtf16>

   585 	{

   586 public:	

   587 	static void Create(const TDesC& aDbFileName)

   588 		{

   589 		(void)TheFs.Delete(aDbFileName);

   590 		HBufC16* dbName = HBufC16::New(aDbFileName.Length() + 1);

   591 		TEST(dbName != NULL);

   592 		dbName->Des().Copy(aDbFileName);

   593 		sqlite3* dbHandle = NULL;

   594 		TInt err = sqlite3_open16((const void*)(dbName->Des().PtrZ()), &dbHandle);

   595 		delete dbName;

   596 		PanicIfError(dbHandle, err);

   597 		HBufC8* createDbScript = ReadSqlScript<HBufC8>(KCreateDbScript());

   598 		HBufC8* createDbScript2 = HBufC8::New(createDbScript->Des().Length() + 1);

   599 		TEST(createDbScript2 != NULL);

   600 		createDbScript2->Des().Copy(createDbScript->Des());

   601 		delete createDbScript;

   602 		createDbScript2->Des().Append(TChar(0));

   603 		err = sqlite3_exec(dbHandle, (const char*)createDbScript2->Des().Ptr(), NULL, 0, NULL);

   604 		PanicIfError(dbHandle, err);

   605 		delete createDbScript2;

   606 		(void)sqlite3_close(dbHandle);

   607 		}

   608 	static sqlite3* Open(const TDesC& aDbFileName)

   609 		{

   610 		HBufC16* dbName = HBufC16::New(aDbFileName.Length() + 1);

   611 		TEST(dbName != NULL);

   612 		dbName->Des().Copy(aDbFileName);

   613 		sqlite3* dbHandle = NULL;

   614 		TInt err = sqlite3_open16((const void*)(dbName->Des().PtrZ()), &dbHandle);

   615 		delete dbName;

   616 		PanicIfError(dbHandle, err);

   617 		return dbHandle;

   618 		}

   619 	};

   620 

   621 template <class HBUFC, class PTRC, class DESC> void InsertTest2(sqlite3* aDbHandle, const TDesC& aScriptFileName, const DESC& aCommitStr);

   622 

   623 //Explicit InsertTest2() template specialization for UTF8 encoded SQL strings

   624 template <> void InsertTest2<HBufC8, TPtrC8, TDesC8>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC8& aCommitStr)

   625 	{

   626 	TheTest.Printf(_L("\"Insert\" test\r\n"));

   627 	HBufC8* fillDbScript = ReadSqlScript<HBufC8>(aScriptFileName);

   628 	TUint32 start = User::FastCounter();

   629 	TPtrC8 ptr(fillDbScript->Des());

   630 	TPtrC8 sql(GetNextTrans<TPtrC8, TDesC8>(ptr, aCommitStr));

   631 	while(sql.Length() > 0)

   632 		{

   633 		TUint8* p = (TUint8*)sql.Ptr();

   634 		p[sql.Length() - 1] = 0;

   635 		TInt err = sqlite3_exec(aDbHandle, (const char*)sql.Ptr(), NULL, 0, NULL);

   636 		PanicIfError(aDbHandle, err);

   637 		sql.Set(GetNextTrans<TPtrC8, TDesC8>(ptr, aCommitStr));

   638 		}

   639 	TUint32 end = User::FastCounter();

   640 	PrintStats(start, end);

   641 	delete fillDbScript;

   642 	}

   643 

   644 //Explicit InsertTest2() template specialization for UTF16 encoded SQL strings

   645 template <> void InsertTest2<HBufC16, TPtrC16, TDesC16>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC16& aCommitStr)

   646 	{

   647 	TheTest.Printf(_L("\"Insert\" test\r\n"));

   648 	HBufC16* fillDbScript = ReadSqlScript<HBufC16>(aScriptFileName);

   649 	TUint32 start = User::FastCounter();

   650 	TPtrC16 ptr(fillDbScript->Des());

   651 	TPtrC16 sql(GetNextTrans<TPtrC16, TDesC16>(ptr, aCommitStr));

   652 	while(sql != KNullDesC16)

   653 		{

   654 		TPtr16 p((TUint16*)sql.Ptr(), sql.Length(), sql.Length());

   655 		TPtrC16 current(KNullDesC16);

   656 		while(p.Length() > 1) //"> 1" because it is a zero terminated string

   657 			{

   658 			current.Set(GetFirstSqlStmt(p));

   659 			sqlite3_stmt* stmtHandle = NULL;

   660 			const void* stmtTail = NULL;

   661 			TInt err = sqlite3_prepare16_v2(aDbHandle, current.Ptr(), -1, &stmtHandle, &stmtTail);

   662 			if(stmtHandle)	//stmtHandle can be NULL for statements like this: ";".

   663 				{

   664 				if(err == SQLITE_OK)

   665 					{

   666 					while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)

   667 						{

   668 						}

   669 					}

   670 				TInt err2 = sqlite3_finalize(stmtHandle);

   671 				TEST2(err2, SQLITE_OK);

   672 				}

   673 			if(ReportIfError(aDbHandle, err))

   674 				{

   675 				delete fillDbScript;

   676 				return;

   677 				}

   678   			}//while(p.Length() > 1)

   679 		sql.Set(GetNextTrans<TPtrC16, TDesC16>(ptr, aCommitStr));

   680 		}//while(sql != KNullDesC16)

   681 	TUint32 end = User::FastCounter();

   682 	PrintStats(start, end);

   683 	delete fillDbScript;

   684 	}

   685 

   686 template <class HBUFC, class DESC> void UpdateTest2(sqlite3* aDbHandle, const DESC& aUpdateSql);

   687 

   688 //Explicit UpdateTest2() template specialization for UTF8 encoded SQL strings

   689 template <> void UpdateTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aUpdateSql)

   690 	{

   691 	TheTest.Printf(_L("\"Update\" test\r\n"));

   692 	HBufC8* sql = HBufC8::New(aUpdateSql.Length() + 1);

   693 	TEST(sql != NULL);

   694 	sql->Des().Copy(aUpdateSql);

   695 	sql->Des().Append(TChar(0));

   696 

   697 	sqlite3_stmt* stmtHandle = NULL;

   698 	const char* stmtTail = NULL;

   699 	TInt err = sqlite3_prepare_v2(aDbHandle, (const char*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail);

   700 	delete sql;

   701 	PanicIfError(aDbHandle, err);

   702 	TInt firstNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName1);

   703 	TEST(firstNamePrmIdx >= 0);

   704 	TInt lastNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName2);

   705 	TEST(lastNamePrmIdx >= 0);

   706 	TInt companyNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName3);

   707 	TEST(companyNamePrmIdx >= 0);

   708 	TInt idIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName4);

   709 	TEST(idIdx >= 0);

   710 	

   711 	TUint32 start = User::FastCounter();

   712 	for(TInt id=1;id<=KTestTecordCount;++id)

   713 		{

   714 		TBuf8<20> buf1;

   715 		buf1.Copy(KFirstName);

   716 		buf1.AppendNum(id);

   717 		buf1.Append(TChar(0));

   718 		err = sqlite3_bind_text(stmtHandle, firstNamePrmIdx, (const char*)buf1.Ptr(), -1, SQLITE_STATIC);

   719 		TEST2(err, SQLITE_OK);

   720 		TBuf8<20> buf2;

   721 		buf2.Copy(KLastName);

   722 		buf2.AppendNum(id);

   723 		buf2.Append(TChar(0));

   724 		err = sqlite3_bind_text(stmtHandle, lastNamePrmIdx, (const char*)buf2.Ptr(), -1, SQLITE_STATIC);

   725 		TEST2(err, SQLITE_OK);

   726 		TBuf8<20> buf3;

   727 		buf3.Copy(KCompanyName);

   728 		buf3.AppendNum(id);

   729 		buf3.Append(TChar(0));

   730 		err = sqlite3_bind_text(stmtHandle, companyNamePrmIdx, (const char*)buf3.Ptr(), -1, SQLITE_STATIC);

   731 		TEST2(err, SQLITE_OK);

   732 		err = sqlite3_bind_int(stmtHandle, idIdx, id);

   733 		TEST2(err, SQLITE_OK);

   734 		while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)

   735 			{

   736 			}

   737 		PanicIfError(aDbHandle, err);

   738 		err = sqlite3_reset(stmtHandle);

   739 		PanicIfError(aDbHandle, err);

   740 		}

   741 	TUint32 end = User::FastCounter();

   742 	PrintStats(start, end);

   743 	err = sqlite3_finalize(stmtHandle);

   744 	TEST2(err, SQLITE_OK);

   745 	}

   746 

   747 //Explicit UpdateTest2() template specialization for UTF16 encoded SQL strings

   748 template <> void UpdateTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aUpdateSql)

   749 	{

   750 	TheTest.Printf(_L("\"Update\" test\r\n"));

   751 	HBufC16* sql = HBufC16::New(aUpdateSql.Length() + 1);

   752 	TEST(sql != NULL);

   753 	sql->Des().Copy(aUpdateSql);

   754 	sql->Des().Append(TChar(0));

   755 

   756 	sqlite3_stmt* stmtHandle = NULL;

   757 	const void* stmtTail = NULL;

   758 	TInt err = sqlite3_prepare16_v2(aDbHandle, (const void*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail);

   759 	delete sql;

   760 	PanicIfError(aDbHandle, err);

   761 	TInt firstNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName1);

   762 	TEST(firstNamePrmIdx >= 0);

   763 	TInt lastNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName2);

   764 	TEST(lastNamePrmIdx >= 0);

   765 	TInt companyNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName3);

   766 	TEST(companyNamePrmIdx >= 0);

   767 	TInt idIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName4);

   768 	TEST(idIdx >= 0);

   769 	

   770 	TUint32 start = User::FastCounter();

   771 	for(TInt id=1;id<=KTestTecordCount;++id)

   772 		{

   773 		TBuf16<20> buf1;

   774 		buf1.Copy(KFirstName);

   775 		buf1.AppendNum(id);

   776 		buf1.Append(TChar(0));

   777 		err = sqlite3_bind_text16(stmtHandle, firstNamePrmIdx, (const void*)buf1.Ptr(), -1, SQLITE_STATIC);

   778 		TEST2(err, SQLITE_OK);

   779 		TBuf16<20> buf2;

   780 		buf2.Copy(KLastName);

   781 		buf2.AppendNum(id);

   782 		buf2.Append(TChar(0));

   783 		err = sqlite3_bind_text16(stmtHandle, lastNamePrmIdx, (const void*)buf2.Ptr(), -1, SQLITE_STATIC);

   784 		TEST2(err, SQLITE_OK);

   785 		TBuf16<20> buf3;

   786 		buf3.Copy(KCompanyName);

   787 		buf3.AppendNum(id);

   788 		buf3.Append(TChar(0));

   789 		err = sqlite3_bind_text16(stmtHandle, companyNamePrmIdx, (const void*)buf3.Ptr(), -1, SQLITE_STATIC);

   790 		TEST2(err, SQLITE_OK);

   791 		err = sqlite3_bind_int(stmtHandle, idIdx, id);

   792 		TEST2(err, SQLITE_OK);

   793 		while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)

   794 			{

   795 			}

   796 		PanicIfError(aDbHandle, err);

   797 		err = sqlite3_reset(stmtHandle);

   798 		PanicIfError(aDbHandle, err);

   799 		}

   800 	TUint32 end = User::FastCounter();

   801 	PrintStats(start, end);

   802 	err = sqlite3_finalize(stmtHandle);

   803 	TEST2(err, SQLITE_OK);

   804 	}

   805 

   806 //"UPDATE" test function (without parameters) - SQLITE

   807 template <class DESC> void UpdateWPTest2(const TDesC& aDbName, const DESC& aUpdateSql);

   808 

   809 //Explicit UpdateWPTest2() template specialization for UTF8 encoded SQL strings

   810 template <> void UpdateWPTest2<TDesC8>(const TDesC& aDbName, const TDesC8& aUpdateSql)

   811 	{

   812 	TheTest.Printf(_L("\"Update (without parameters)\" test\r\n"));

   813 	TBuf<200> fmtstr;

   814 	fmtstr.Copy(aUpdateSql);

   815 

   816 	sqlite3SymbianLibInit();

   817 	sqlite3* dbHandle = TDbHelper2<EDbUtf8>::Open(aDbName);

   818 	

   819 	TUint32 start = User::FastCounter();

   820 	for(TInt id=1;id<=KTestTecordCount;++id)

   821 		{

   822 		TBuf<200> buf;

   823 		buf.Format(fmtstr, &KFirstName2, id, &KLastName2, id, &KCompanyName2, id, id);

   824 		TBuf8<200> sql;

   825 		sql.Copy(buf);

   826 		sql.Append(0);

   827 		TInt err = sqlite3_exec(dbHandle, (const char*)sql.Ptr(), 0, 0, 0);

   828 		TEST2(err, SQLITE_OK);

   829 		}

   830 	TUint32 end = User::FastCounter();

   831 	PrintStats(start, end);

   832 	

   833 	TInt err2 = sqlite3_close(dbHandle);

   834 	TEST2(err2, SQLITE_OK);

   835 	sqlite3SymbianLibFinalize();

   836 	CloseSTDLIB();

   837 	}

   838 

   839 //Explicit UpdateWPTest2() template specialization for UTF16 encoded SQL strings

   840 template <> void UpdateWPTest2<TDesC16>(const TDesC& aDbName, const TDesC16& aUpdateSql)

   841 	{

   842 	TheTest.Printf(_L("\"Update (without parameters)\" test\r\n"));

   843 

   844 	sqlite3SymbianLibInit();

   845 	sqlite3* dbHandle = TDbHelper2<EDbUtf16>::Open(aDbName);

   846 	

   847 	TUint32 start = User::FastCounter();

   848 	for(TInt id=1;id<=KTestTecordCount;++id)

   849 		{

   850 		TBuf<200> sql;

   851 		sql.Format(aUpdateSql, &KFirstName2, id, &KLastName2, id, &KCompanyName2, id, id);

   852 		sql.Append(0);

   853 		sqlite3_stmt* stmtHandle = NULL;

   854 		const void* stmtTail = NULL;

   855 		TInt err = sqlite3_prepare16_v2(dbHandle, sql.Ptr(), -1, &stmtHandle, &stmtTail);

   856 		TEST2(err, SQLITE_OK);

   857 		if(stmtHandle)	//stmtHandle can be NULL for statements like this: ";".

   858 			{

   859 			if(err == SQLITE_OK)

   860 				{

   861 				while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)

   862 					{

   863 					}

   864 				}

   865 			TInt err2 = sqlite3_finalize(stmtHandle);

   866 			TEST2(err2, SQLITE_OK);

   867 			TEST2(err, SQLITE_DONE);

   868 			}

   869 		}

   870 	TUint32 end = User::FastCounter();

   871 	PrintStats(start, end);

   872 	

   873 	TInt err2 = sqlite3_close(dbHandle);

   874 	TEST2(err2, SQLITE_OK);

   875 	sqlite3SymbianLibFinalize();

   876 	CloseSTDLIB();

   877 	}

   878 

   879 template <class HBUFC, class DESC> void SelectTest2(sqlite3* aDbHandle, const DESC& aSelectSql);

   880 

   881 //Explicit SelectTest2() template specialization for UTF8 encoded SQL strings

   882 template <> void SelectTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aSelectSql)

   883 	{

   884 	TheTest.Printf(_L("\"Select\" test\r\n"));

   885 	HBufC8* sql = HBufC8::New(aSelectSql.Length() + 1);

   886 	TEST(sql != NULL);

   887 	sql->Des().Copy(aSelectSql);

   888 	sql->Des().Append(TChar(0));

   889 

   890 	sqlite3_stmt* stmtHandle = NULL;

   891 	const char* stmtTail = NULL;

   892 	TInt err = sqlite3_prepare_v2(aDbHandle, (const char*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail);

   893 	delete sql;

   894 	PanicIfError(aDbHandle, err);

   895 	

   896 	TUint32 start = User::FastCounter();

   897 	while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)

   898 		{

   899 		TBuf8<20> buf;

   900 		const unsigned char* p = sqlite3_column_text(stmtHandle, 0);

   901 		buf.Copy(p, User::StringLength(p));

   902 		TEST(buf.Length() > 0);

   903 		p = sqlite3_column_text(stmtHandle, 1);

   904 		buf.Copy(p, User::StringLength(p));

   905 		TEST(buf.Length() > 0);

   906 		p = sqlite3_column_text(stmtHandle, 2);

   907 		buf.Copy(p, User::StringLength(p));

   908 		TEST(buf.Length() > 0);

   909 		}

   910 	TEST2(err, SQLITE_DONE);

   911 	TUint32 end = User::FastCounter();

   912 	PrintStats(start, end);

   913 	err = sqlite3_finalize(stmtHandle);

   914 	TEST2(err, SQLITE_OK);

   915 	}

   916 

   917 //Explicit SelectTest2() template specialization for UTF16 encoded SQL strings

   918 template <> void SelectTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aSelectSql)

   919 	{

   920 	TheTest.Printf(_L("\"Select\" test\r\n"));

   921 	HBufC16* sql = HBufC16::New(aSelectSql.Length() + 1);

   922 	TEST(sql != NULL);

   923 	sql->Des().Copy(aSelectSql);

   924 	sql->Des().Append(TChar(0));

   925 

   926 	sqlite3_stmt* stmtHandle = NULL;

   927 	const void* stmtTail = NULL;

   928 	TInt err = sqlite3_prepare16_v2(aDbHandle, (const void*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail);

   929 	delete sql;

   930 	PanicIfError(aDbHandle, err);

   931 	

   932 	TUint32 start = User::FastCounter();

   933 	while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)

   934 		{

   935 		TBuf16<20> buf;

   936 		const void* p = sqlite3_column_text16(stmtHandle, 0);

   937 		buf.Copy((const TUint16*)p, User::StringLength((const TUint16*)p));

   938 		TEST(buf.Length() > 0);

   939 		p = sqlite3_column_text16(stmtHandle, 1);

   940 		buf.Copy((const TUint16*)p, User::StringLength((const TUint16*)p));

   941 		TEST(buf.Length() > 0);

   942 		p = sqlite3_column_text16(stmtHandle, 2);

   943 		buf.Copy((const TUint16*)p, User::StringLength((const TUint16*)p));

   944 		TEST(buf.Length() > 0);

   945 		}

   946 	TEST2(err, SQLITE_DONE);

   947 	TUint32 end = User::FastCounter();

   948 	PrintStats(start, end);

   949 	err = sqlite3_finalize(stmtHandle);

   950 	TEST2(err, SQLITE_OK);

   951 	}

   952 

   953 template <class HBUFC, class DESC> void DeleteTest2(sqlite3* aDbHandle, const DESC& aDeleteSql);

   954 

   955 //Explicit DeleteTest2() template specialization for UTF8 encoded SQL strings

   956 template <> void DeleteTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aDeleteSql)

   957 	{

   958 	TheTest.Printf(_L("\"Delete\" test\r\n"));

   959 	HBufC8* sql = HBufC8::New(aDeleteSql.Length() + 1);

   960 	TEST(sql != NULL);

   961 	sql->Des().Copy(aDeleteSql);

   962 	sql->Des().Append(TChar(0));

   963 	TUint32 start = User::FastCounter();

   964 	TInt err = sqlite3_exec(aDbHandle, (const char*)sql->Des().Ptr(), 0, 0, 0);

   965 	TEST2(err, SQLITE_OK);

   966 	TUint32 end = User::FastCounter();

   967 	PrintStats(start, end);

   968 	delete sql;

   969 	}

   970 

   971 //Explicit DeleteTest2() template specialization for UTF16 encoded SQL strings

   972 template <> void DeleteTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aDeleteSql)

   973 	{

   974 	TheTest.Printf(_L("\"Delete\" test\r\n"));

   975 	HBufC16* sql = HBufC16::New(aDeleteSql.Length() + 1);

   976 	TEST(sql != NULL);

   977 	sql->Des().Copy(aDeleteSql);

   978 	sql->Des().Append(TChar(0));

   979 	TUint32 start = User::FastCounter();

   980 	sqlite3_stmt* stmtHandle = NULL;

   981 	const void* stmtTail = NULL;

   982 	TInt err = sqlite3_prepare16_v2(aDbHandle, sql->Des().Ptr(), -1, &stmtHandle, &stmtTail);

   983 	TEST2(err, SQLITE_OK);

   984 	if(stmtHandle)	//stmtHandle can be NULL for statements like this: ";".

   985 		{

   986 		if(err == SQLITE_OK)

   987 			{

   988 			while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW)

   989 				{

   990 				}

   991 			}

   992 		TInt err2 = sqlite3_finalize(stmtHandle);

   993 		TEST2(err2, SQLITE_OK);

   994 		TEST2(err, SQLITE_DONE);

   995 		}

   996 	TUint32 end = User::FastCounter();

   997 	PrintStats(start, end);

   998 	delete sql;

   999 	}

  1000 

  1001 template <TDbEncoding TYPE, class HBUFC, class PTRC, class DESC> void PerformanceTest2(const TDesC& aDbFileName, 

  1002 																					   const DESC& aCommitStr,

  1003 																					   const DESC& aUpdateSql,

  1004 																					   const DESC& aSelectSql,

  1005 																					   const DESC& aDeleteSql)

  1006 	{

  1007 	CFileMan* fm = NULL;

  1008 	TRAPD(err, fm = CFileMan::NewL(TheFs));

  1009 	TEST2(err, KErrNone);

  1010 	

  1011 	sqlite3SymbianLibInit();

  1012 	TDbHelper2<TYPE>::Create(aDbFileName);

  1013 	

  1014 	sqlite3* dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);

  1015 	InsertTest2<HBUFC, PTRC, DESC>(dbHandle, KFillDbScript(), aCommitStr);

  1016 	(void)sqlite3_close(dbHandle); dbHandle = NULL;

  1017 	PrintFileSize(aDbFileName);

  1018 

  1019 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);

  1020 	UpdateTest2<HBUFC, DESC>(dbHandle, aUpdateSql);

  1021 	(void)sqlite3_close(dbHandle); dbHandle = NULL;

  1022 

  1023 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);

  1024 	SelectTest2<HBUFC, DESC>(dbHandle, aSelectSql);

  1025 	(void)sqlite3_close(dbHandle); dbHandle = NULL;

  1026 

  1027 	(void)fm->Copy(aDbFileName, TheNonSecureTmpDbName);

  1028 	

  1029 	dbHandle = TDbHelper2<TYPE>::Open(aDbFileName);

  1030 	DeleteTest2<HBUFC, DESC>(dbHandle, aDeleteSql);

  1031 	(void)sqlite3_close(dbHandle); dbHandle = NULL;

  1032 	PrintFileSize(aDbFileName);

  1033 	

  1034 	sqlite3SymbianLibFinalize();

  1035 	CloseSTDLIB();

  1036 

  1037 	(void)fm->Copy(TheNonSecureTmpDbName, aDbFileName);

  1038 	(void)fm->Delete(TheNonSecureTmpDbName);

  1039 	delete fm;

  1040 	}

  1041 //Explicit PerformanceTest2() template instantiations.

  1042 template void PerformanceTest2<EDbUtf8, HBufC8, TPtrC8, TDesC8>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&);

  1043 template void PerformanceTest2<EDbUtf16, HBufC8, TPtrC8, TDesC8>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&);

  1044 template void PerformanceTest2<EDbUtf8, HBufC16, TPtrC16, TDesC16>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&);

  1045 template void PerformanceTest2<EDbUtf16, HBufC16, TPtrC16, TDesC16>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&);

  1046 

  1047 void ColumnValueAccessTest()

  1048 	{

  1049 	_LIT(KColName1, "Column1");

  1050 	_LIT(KColName2, "Column2");

  1051 	_LIT(KColName3, "Column3");

  1052 	_LIT(KColName4, "Column4");

  1053 	const TInt KColCount = 4;

  1054 	TPtrC colNames[KColCount] = {KColName1(), KColName2(), KColName3(), KColName4()};

  1055 	TBuf<100> sql;

  1056 	

  1057 	//Create a test database

  1058 	RSqlDatabase db;

  1059 	TInt err = db.Create(TheNonSecureDbName2);		

  1060 	TEST2(err, KErrNone);

  1061 	_LIT(KCreateSql, "CREATE TABLE A(%S INTEGER, %S INTEGER, %S INTEGER, %S INTEGER)");

  1062 	sql.Format(KCreateSql, &colNames[0], &colNames[1], &colNames[2], &colNames[3]);

  1063 	err = db.Exec(sql);

  1064 	TEST(err >= 0);	

  1065 	//Insert a record in the test database

  1066 	_LIT(KInsertSql, "INSERT INTO A(%S, %S, %S, %S) VALUES(0, 1, 2, 3)");

  1067 	sql.Format(KInsertSql, &colNames[0], &colNames[1], &colNames[2], &colNames[3]);

  1068 	err = db.Exec(sql);

  1069 	TEST2(err, 1);

  1070 	//Retrieve the record

  1071 	RSqlStatement stmt;

  1072 	err = stmt.Prepare(db, _L8("SELECT * FROM A"));

  1073 	TEST2(err, KErrNone);

  1074 	err = stmt.Next();

  1075 	TEST2(err, KSqlAtRow);

  1076 	

  1077 	//Init the random numbers generator

  1078 	TInt64 seed = (TInt64)&ColumnValueAccessTest;

  1079 	const TInt KTestCount = 20000;

  1080 	TInt val;

  1081 	

  1082 	//Test 1: retrieve column values using the column index

  1083 	TUint32 start = User::FastCounter();

  1084 	for(TInt i1=0;i1<KTestCount;++i1)	

  1085 		{

  1086 		TInt colIdx = Math::Rand(seed) % KColCount;

  1087 		val = stmt.ColumnInt(colIdx);

  1088 		TEST(val == colIdx);

  1089 		}

  1090 	TUint32 end = User::FastCounter();

  1091 	PrintStats(start, end);

  1092 	

  1093 	//Test 2: retrieve column values using the column name

  1094 	start = User::FastCounter();

  1095 	for(TInt i2=0;i2<KTestCount;++i2)	

  1096 		{

  1097 		TInt colNameIdx = Math::Rand(seed) % KColCount;

  1098 		TInt colIdx = stmt.ColumnIndex(colNames[colNameIdx]);

  1099 		val = stmt.ColumnInt(colIdx);

  1100 		TEST(val == colIdx);

  1101 		}

  1102 	end = User::FastCounter();

  1103 	PrintStats(start, end);

  1104 	

  1105 	//Cleanup

  1106 	stmt.Close();

  1107 	db.Close();

  1108 	(void)RSqlDatabase::Delete(TheNonSecureDbName2);

  1109 	}

  1110 

  1111 ///////////////////////////////////////////////////////////////////////////////////

  1112 ////////////      "Single record" INSERT/UPDATE/DELETE tests       ////////////////

  1113 ///////////////////////////////////////////////////////////////////////////////////

  1114 

  1115 _LIT(KZDbName, "z:\\test\\default_avacon.dbSQL");

  1116 

  1117 RSqlDatabase TheDb;

  1118 

  1119 void OpenTestDb()

  1120 	{

  1121 	(void)RSqlDatabase::Delete(TheSglRecDbFileName);

  1122 	TInt err = RSqlDatabase::Copy(KZDbName, TheSglRecDbFileName);

  1123 	TEST2(err, KErrNone);

  1124 	err = TheDb.Open(TheSglRecDbFileName);

  1125 	TEST2(err, KErrNone);

  1126 	}

  1127 	

  1128 void CloseTestDb()

  1129 	{

  1130 	TheDb.Close();

  1131 	TInt err = RSqlDatabase::Delete(TheSglRecDbFileName);

  1132 	TEST2(err, KErrNone);

  1133 	}

  1134