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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32test.h>

#include <e32math.h>

#include <bautils.h>

#include <hal.h>

#include <d32dbms.h>

///////////////////////////////////////////////////////////////////////////////////////

RTest TheTest(_L("t_dbperf1"));

RFs   TheFs;

RDbs  TheDbs;

TFileName TheNonSecureDbName;

TFileName TheNonSecureDbName2;

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

_LIT(KUpdateSql, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME='%S%d',CM_LASTNAME='%S%d',CM_COMPANYNAME='%S%d' WHERE PARENT_CMID=%d");

_LIT(KSelectSql, "SELECT CM_FIRSTNAME, CM_LASTNAME, CM_COMPANYNAME FROM IDENTITYTABLE WHERE PARENT_CMID > 50");

_LIT(KDeleteSql, "DELETE FROM IDENTITYTABLE WHERE PARENT_CMID > 50");

_LIT(KFirstName, "FirstName-");

_LIT(KLastName, "LastName-");

_LIT(KCompanyName, "CompanyName-");

const TInt KTestTecordCount = 1000;

enum TTestType 

	{

	EClientDbTest,		

	EServerDbTest

	};

enum TCompactDbOption

	{

	ENoCompaction,

	ECompactAfterCommit,

	ECompactAfterEvery10Rec,

	ECompactAfterEveryUpd,

	ECompactAtEnd

	};

///////////////////////////////////////////////////////////////////////////////////////

void TestEnvDestroy()

	{

	TheDbs.Close();

	TheFs.Delete(TheNonSecureDbName2);

	TheFs.Delete(TheNonSecureDbName);

	TheFs.Close();

	}

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Test macros and functions

void Check1(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TestEnvDestroy();

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

		TheTest(EFalse, aLine);

		}

	}

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

	{

	if(aValue != aExpected)

		{

		TestEnvDestroy();

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

		TheTest(EFalse, aLine);

		}

	}

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

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

///////////////////////////////////////////////////////////////////////////////////////

void TestEnvInit()

    {

	TInt err = TheFs.Connect();

	TEST2(err, KErrNone);

	err = TheFs.MkDir(TheNonSecureDbName);

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

	err = TheDbs.Connect();

	TEST2(err, KErrNone);

	}

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

//The caller is responsible for destroying the returned HBufC object.

HBufC* ReadSqlScript(const TDesC& aSqlFileName)

	{

	RFile file;

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

	TInt size = 0;

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

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

	TEST(sql != NULL);

	TPtr8 ptr = sql->Des();

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

	file.Close();

	HBufC* sql2 = HBufC::New(size);

	TEST(sql2 != NULL);

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

	delete sql;

	return sql2;

	}

//Searches for the next ';' appearance in aSqlScript string and returns a TPtrC object holding

//the SQL statement, terminated with that ';'.

TPtrC GetNextStmt(TPtrC& aSqlScript)

	{

	_LIT(KTerminator, ";\xD");

	TPtrC res(NULL, 0);

	TInt pos = aSqlScript.FindF(KTerminator());

	if(pos >= 0)

		{

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

		pos += 1;

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

		}

	return res;

	}

//Prints aTime parameter (converted to ms)

void PrintStats(TUint32 aStartTicks, TUint32 aEndTicks)

	{

	static TInt freq = 0;

	if(freq == 0)

		{

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

		}

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

	if(diffTicks < 0)

		{

		diffTicks = KMaxTUint32 + diffTicks + 1;

		}

	const TInt KMicroSecIn1Sec = 1000000;

	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

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

	}

void PrintFileSize(const TDesC& aFileName)

	{

	RFile file;

	TInt err = file.Open(TheFs, aFileName, EFileRead);

	TEST2(err, KErrNone);

	TInt size = 0;

	err = file.Size(size);

	TEST2(err, KErrNone);

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

	file.Close();

	}

void PrintString(const TDesC& aStr)

	{

	TheTest.Printf(_L("Str begin~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n"));

	TPtrC ptr(aStr);

	while(ptr.Length() > 0)

		{

		TPtrC ptr2;

		TInt len = Min(ptr.Length(), 60);

		ptr2.Set(ptr.Left(len));

		TheTest.Printf(_L("%S\r\n"), &ptr2);

		ptr.Set(ptr.Mid(len));

		}

	TheTest.Printf(_L("Str end~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n"));

	}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////     DBMS SERVER performance tests

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Creates aDb database schema.

void CreateDbSchemaL(RDbDatabase& aDb)

	{

	//"Contacts" table

	CDbColSet* colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_type"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_preftemplaterefid"), EDbColInt32));

	colSet->AddL(TDbCol(_L("cm_uidstring"), EDbColText, 244));

	colSet->AddL(TDbCol(_L("cm_last_modified"), EDbColDateTime));

	colSet->AddL(TDbCol(_L("cm_contactcreationdate"), EDbColDateTime));

	colSet->AddL(TDbCol(_L("cm_attributes"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_replicationcount"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_header"), EDbColLongText));

	colSet->AddL(TDbCol(_L("cm_textblob"), EDbColLongText));

	colSet->AddL(TDbCol(_L("cm_searchabletext"), EDbColLongText));

	TInt err = aDb.CreateTable(_L("contacts"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//"identitytable" table

	colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("parent_cmid"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_firstname"), EDbColText, 255));

	colSet->AddL(TDbCol(_L("cm_lastname"), EDbColText, 255));

	colSet->AddL(TDbCol(_L("cm_companyname"), EDbColText, 255));

	colSet->AddL(TDbCol(_L("cm_type"), EDbColInt32));

	colSet->AddL(TDbCol(_L("cm_attributes"), EDbColInt32));

	colSet->AddL(TDbCol(_L("cm_hintfield"), EDbColUint8));

	colSet->AddL(TDbCol(_L("cm_exthintfield"), EDbColUint16));

	colSet->AddL(TDbCol(_L("cm_firstnmprn"), EDbColText, 255));

	colSet->AddL(TDbCol(_L("cm_lastnmprn"), EDbColText, 255));

	colSet->AddL(TDbCol(_L("cm_companynmprn"), EDbColText, 255));

	err = aDb.CreateTable(_L("identitytable"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//"emailtable" table

	colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("emailparent_cmid"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("email_fieldid"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("emailaddress"), EDbColText, 255));

	err = aDb.CreateTable(_L("emailtable"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//"phone" table

	colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_phonematching"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_extendedphonematching"), EDbColInt32, TDbCol::ENotNull));

	err = aDb.CreateTable(_L("phone"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//"groups" table

	colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_members"), EDbColInt32, TDbCol::ENotNull));

	err = aDb.CreateTable(_L("groups"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//"groups2" table

	colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_groupmembers"), EDbColLongText));

	err = aDb.CreateTable(_L("groups2"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//"sync" table

	colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_lastsyncdate"), EDbColDateTime));

	err = aDb.CreateTable(_L("sync"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//"preferences" table

	colSet = CDbColSet::NewLC();

	colSet->AddL(TDbCol(_L("cm_preffileid"), EDbColInt16));

	colSet->AddL(TDbCol(_L("cm_preftemplateid"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_prefowncardid"), EDbColInt32));

	colSet->AddL(TDbCol(_L("cm_prefcardtemplateprefid"), EDbColInt32));

	colSet->AddL(TDbCol(_L("cm_preffilever"), EDbColInt32, TDbCol::ENotNull));

	colSet->AddL(TDbCol(_L("cm_prefcardtemplateid"), EDbColLongText));

	colSet->AddL(TDbCol(_L("cm_prefgroupidlist"), EDbColLongText));

	colSet->AddL(TDbCol(_L("cm_creationdate"), EDbColDateTime));

	colSet->AddL(TDbCol(_L("cm_machineuid"), EDbColInt64));

	colSet->AddL(TDbCol(_L("cm_prefsortorder"), EDbColLongText));

	err = aDb.CreateTable(_L("preferences"), *colSet);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); colSet = NULL;

	//////////////////////////////////////////////////////////////////////////////////////////////////////////

	//////////////////////////////////////////////////////////////////////////////////////////////////////////

	//"Contacts" table keys

	CDbKey* key = CDbKey::NewLC();

	key->AddL(_L("cm_id"));

	key->MakeUnique();

	err = aDb.CreateIndex(_L("contacts"), _L("contacts"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	key = CDbKey::NewLC();

	key->AddL(_L("cm_preftemplaterefid"));

	err = aDb.CreateIndex(_L("cm_preftemplaterefid"), _L("contacts"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	//"identitytable" table keys

	key = CDbKey::NewLC();

	key->AddL(_L("parent_cmid"));

	key->MakeUnique();

	err = aDb.CreateIndex(_L("identitytable"), _L("identitytable"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	//"emailtable" table keys

	key = CDbKey::NewLC();

	key->AddL(_L("email_fieldid"));

	key->AddL(_L("emailparent_cmid"));

	key->MakeUnique();

	err = aDb.CreateIndex(_L("emailtable"), _L("emailtable"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	key = CDbKey::NewLC();

	key->AddL(_L("emailparent_cmid"));

	err = aDb.CreateIndex(_L("emailparent_cmid"), _L("emailtable"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	//"phone" table keys

	key = CDbKey::NewLC();

	key->AddL(_L("cm_phonematching"));

	key->AddL(_L("cm_id"));

	key->MakeUnique();

	err = aDb.CreateIndex(_L("phone"), _L("phone"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	key = CDbKey::NewLC();

	key->AddL(_L("cm_id"));

	err = aDb.CreateIndex(_L("cm_id"), _L("phone"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	//"groups" table keys

	key = CDbKey::NewLC();

	key->AddL(_L("cm_members"));

	key->AddL(_L("cm_id"));

	key->MakeUnique();

	err = aDb.CreateIndex(_L("groups"), _L("groups"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	key = CDbKey::NewLC();

	key->AddL(_L("cm_id"));

	err = aDb.CreateIndex(_L("cm_id"), _L("groups"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	key = CDbKey::NewLC();

	key->AddL(_L("cm_members"));

	err = aDb.CreateIndex(_L("cm_members"), _L("groups"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	//"groups2" table keys

	key = CDbKey::NewLC();

	key->AddL(_L("cm_id"));

	key->MakeUnique();

	err = aDb.CreateIndex(_L("groups2"), _L("groups2"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	//"sync" table keys

	key = CDbKey::NewLC();

	key->AddL(_L("cm_id"));

	key->MakeUnique();

	err = aDb.CreateIndex(_L("sync"), _L("sync"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	//"preferences" table keys

	key = CDbKey::NewLC();

	key->AddL(_L("cm_preftemplateid"));

	err = aDb.CreateIndex(_L("cm_preftemplateid"), _L("preferences"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	key = CDbKey::NewLC();

	key->AddL(_L("cm_prefowncardid"));

	err = aDb.CreateIndex(_L("cm_prefowncardid"), _L("preferences"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	key = CDbKey::NewLC();

	key->AddL(_L("cm_prefcardtemplateprefid"));

	err = aDb.CreateIndex(_L("cm_prefcardtemplateprefid"), _L("preferences"), *key);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(); key = NULL;

	}

class TDbHelper

	{

public:	

	static void CreateL(const TDesC& aDbName)

		{

		RDbNamedDatabase db;

		TInt err = db.Replace(TheFs, aDbName);

		TEST2(err, KErrNone);

		CreateDbSchemaL(db);

		db.Close();

		}

	static RDbDatabase Open(TTestType aTestType, const TDesC& aDbName)

		{

		RDbNamedDatabase db;

		TInt err = aTestType == EClientDbTest ? db.Open(TheFs, aDbName) : db.Open(TheDbs, aDbName);

		TEST2(err, KErrNone);

		return db;

		}

	};

//Executes SQL script

void ExecuteSqlScript(RDbDatabase& aDb, const TDesC& aScriptFileName, TCompactDbOption aCompactDbOpt)

	{

	if(aCompactDbOpt == ECompactAfterCommit)

		{

		TheTest.Printf(_L("===Execute DB script: Compact after COMMIT\r\n"));	

		}

	else if(aCompactDbOpt == ECompactAtEnd)

		{

		TheTest.Printf(_L("===Execute DB script: Compact at end\r\n"));	

		}

	else

		{

		TheTest.Printf(_L("===Execute DB script: No compaction\r\n"));	

		}

	HBufC* fullDbScript = ReadSqlScript(aScriptFileName);

	TUint32 start = User::FastCounter();

	TPtrC ptr(fullDbScript->Des());

	TInt stmtCnt = 0;

	TInt err = aDb.Begin();

	TEST2(err, KErrNone);

	TPtrC sql(GetNextStmt(ptr));

	while(sql.Length() > 0)

		{

		++stmtCnt;

		TInt rc = aDb.Execute(sql);

		if(rc == KErrNoMemory)

			{

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

			return;	

			}

		if(rc != 1)	

			{

			PrintString(sql);

			}

		TEST2(rc, 1);

		if((stmtCnt % 200) == 0) //~16 transactions (~3270 statements total)

			{

			err = aDb.Commit();	

			TEST2(err, KErrNone);

			if(aCompactDbOpt == ECompactAfterCommit)

				{

				err = aDb.Compact();

				TEST2(err, KErrNone);

				}

			err = aDb.Begin();

			TEST2(err, KErrNone);

			}

		sql.Set(GetNextStmt(ptr));

		}

	err = aDb.Commit();	

	TEST2(err, KErrNone);

	if(aCompactDbOpt == ECompactAfterCommit || aCompactDbOpt == ECompactAtEnd)

		{

		err = aDb.Compact();

		TEST2(err, KErrNone);

		}

	TUint32 end = User::FastCounter();

	PrintStats(start, end);

	delete fullDbScript;

	TheTest.Printf(_L("###Processed records: %d\r\n"), stmtCnt);

	}

///////////////////////////////////////////////////////////////////////////////////////

//"INSERT" test function

void InsertTest(TTestType aTestType, const TDesC& aDbFileName, TCompactDbOption aCompactDbOpt)

	{

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

	RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName);

	ExecuteSqlScript(db, KFillDbScript, aCompactDbOpt);

	RDbTable tbl;

	TInt err = tbl.Open(db, _L("CONTACTS"));

	TEST2(err, KErrNone);

	TInt recCnt = 0;

	TRAP(err, recCnt = tbl.CountL());

	TEST2(err, KErrNone);

	TEST2(recCnt, 1001);

	tbl.Close();

	db.Close();	

	}

//"UPDATE" test function

void UpdateTest(TTestType aTestType, const TDesC& aDbFileName, const TDesC& aUpdateSql, TCompactDbOption aCompactDbOpt)

	{

	if(aCompactDbOpt == ECompactAfterEvery10Rec)

		{

		TheTest.Printf(_L("===Update: Compact after every 10 records\r\n"));	

		}

	else if(aCompactDbOpt == ECompactAfterEveryUpd)

		{

		TheTest.Printf(_L("===Update: Compact after every update\r\n"));	

		}

	else if(aCompactDbOpt == ECompactAtEnd)

		{

		TheTest.Printf(_L("===Update: Compact at end\r\n"));	

		}

	else

		{

		TheTest.Printf(_L("===Update: No compaction\r\n"));	

		}

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

	RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName);

	TUint32 start = User::FastCounter();

	for(TInt id=1,updateOpCnt=0;id<=KTestTecordCount;++id,++updateOpCnt)

		{

		TBuf<200> sql;

		sql.Format(aUpdateSql, &KFirstName, id, &KLastName, id, &KCompanyName, id, id);

		TInt rc = db.Execute(sql);

		if(rc != 1)	

			{

			PrintString(sql);

			}

		TEST2(rc, 1);

		if(aCompactDbOpt == ECompactAfterEveryUpd || (aCompactDbOpt == ECompactAfterEvery10Rec && (updateOpCnt % 10) == 0))

			{

			TInt err = db.Compact();

			TEST2(err, KErrNone);

			}

		}

	if(aCompactDbOpt == ECompactAfterEvery10Rec || aCompactDbOpt == ECompactAtEnd)

		{

		TInt err = db.Compact();

		TEST2(err, KErrNone);

		}

	TUint32 end = User::FastCounter();

	PrintStats(start, end);

	db.Close();

	}

//"SELECT" test function

void SelectTestL(TTestType aTestType, const TDesC& aDbFileName, const TDesC& aSelectSql)

	{

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

	RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName);

	TDbQuery query(aSelectSql);

	RDbView view;

	TInt err = view.Prepare(db, query, RDbRowSet::EReadOnly);

	TEST2(err, KErrNone);

	TUint32 start = User::FastCounter();

	err = view.EvaluateAll();

	TEST2(err, KErrNone);

	while(view.NextL())

		{

		view.GetL();

		TPtrC colVal;

		TBuf<20> res;

		colVal.Set(view.ColDes(1));

		res.Copy(colVal);

		TEST(colVal.Length() > 0);

		colVal.Set(view.ColDes(2));

		TEST(colVal.Length() > 0);

		res.Copy(colVal);

		colVal.Set(view.ColDes(3));

		TEST(colVal.Length() > 0);

		res.Copy(colVal);

		}

	TEST(view.AtEnd());

	view.Close();

	TUint32 end = User::FastCounter();

	PrintStats(start, end);

	db.Close();	

	}

//"DELETE" test function

void DeleteTest(TTestType aTestType, const TDesC& aDbFileName, const TDesC& aDeleteSql, TCompactDbOption aCompactDbOpt)

	{

	if(aCompactDbOpt == ECompactAtEnd)

		{

		TheTest.Printf(_L("===Delete: Compact at end\r\n"));	

		}

	else

		{

		TheTest.Printf(_L("===Delete: No compaction\r\n"));	

		}

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

	RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName);

	TUint32 start = User::FastCounter();

	TInt rc = db.Execute(aDeleteSql);

	TEST(rc > 900);

	if(aCompactDbOpt == ECompactAtEnd)

		{

		TInt err = db.Compact();

		TEST2(err, KErrNone);

		}

	TUint32 end = User::FastCounter();

	PrintStats(start, end);

	db.Close();	

	}

/**

@SYMTestCaseID			PDS-DBMS-CT-4008

@SYMTestCaseDesc		DBMS server performance tests.

						Three test types used: "insert records", "update records" and "select records".

						The tests are executed on non-secure databases.

						Each test executed using UTF16 encoded SQl statements.

						The test results are used for a comparison against the SQL server test results 

						(T_SqlPerformance test).

@SYMTestPriority		High

@SYMTestActions			DBMS server performance tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ5792

                        REQ5793

*/	

void DoTestsL()

	{

	TheTest.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4008 DBMS performance tests"));

	CFileMan* fm = CFileMan::NewL(TheFs);

	CleanupStack::PushL(fm);

	//==================================== CLIENT ==========================================================

	TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, client, no db compaction\r\n"));

	TDbHelper::CreateL(TheNonSecureDbName);

	InsertTest(EClientDbTest, TheNonSecureDbName, ENoCompaction);

	PrintFileSize(TheNonSecureDbName);

	TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, client, db compaction at end\r\n"));

	TDbHelper::CreateL(TheNonSecureDbName);

	InsertTest(EClientDbTest, TheNonSecureDbName, ECompactAtEnd);

	PrintFileSize(TheNonSecureDbName);

	TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, client, db compaction after commit\r\n"));

	TDbHelper::CreateL(TheNonSecureDbName);

	InsertTest(EClientDbTest, TheNonSecureDbName, ECompactAfterCommit);

	PrintFileSize(TheNonSecureDbName);

	TInt err = fm->Copy(TheNonSecureDbName, TheNonSecureDbName2);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, no db compaction\r\n"));

	UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ENoCompaction);

	PrintFileSize(TheNonSecureDbName);

	err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, db compaction at end\r\n"));

	UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAtEnd);

	PrintFileSize(TheNonSecureDbName);

	err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, db compaction after every 10 records\r\n"));

	UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEvery10Rec);

	PrintFileSize(TheNonSecureDbName);

//L	err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName);

//L	TEST2(err, KErrNone);

//L	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, db compaction after every update\r\n"));

//L	UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEveryUpd);

//L	PrintFileSize(TheNonSecureDbName);

	TheTest.Printf(_L("DBMS, select, UTF16 SQL strings, non-secure db, client\r\n"));

	SelectTestL(EClientDbTest, TheNonSecureDbName, KSelectSql());

	TheTest.Printf(_L("DBMS, delete, UTF16 SQL strings, non-secure db, client\r\n"));

	DeleteTest(EClientDbTest, TheNonSecureDbName, KDeleteSql(), ECompactAtEnd);

	PrintFileSize(TheNonSecureDbName);

	//==================================== SERVER ==========================================================

	TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, server, no db compaction\r\n"));

	TDbHelper::CreateL(TheNonSecureDbName);

	InsertTest(EServerDbTest, TheNonSecureDbName, ENoCompaction);

	PrintFileSize(TheNonSecureDbName);

	TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, server, db compaction at end\r\n"));

	TDbHelper::CreateL(TheNonSecureDbName);

	InsertTest(EServerDbTest, TheNonSecureDbName, ECompactAtEnd);

	PrintFileSize(TheNonSecureDbName);

	TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, server, db compaction after commit\r\n"));

	TDbHelper::CreateL(TheNonSecureDbName);

	InsertTest(EServerDbTest, TheNonSecureDbName, ECompactAfterCommit);

	PrintFileSize(TheNonSecureDbName);

	err = fm->Copy(TheNonSecureDbName, TheNonSecureDbName2);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, no db compaction\r\n"));

	UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ENoCompaction);

	PrintFileSize(TheNonSecureDbName);

	err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, db compaction at end\r\n"));

	UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAtEnd);

	PrintFileSize(TheNonSecureDbName);

	err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, db compaction after every 10 records\r\n"));

	UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEvery10Rec);

	PrintFileSize(TheNonSecureDbName);

//L	err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName);

//L	TEST2(err, KErrNone);

//L	TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, db compaction after every update\r\n"));

//L	UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEveryUpd);

//L	PrintFileSize(TheNonSecureDbName);

	TheTest.Printf(_L("DBMS, select, UTF16 SQL strings, non-secure db, server\r\n"));

	SelectTestL(EServerDbTest, TheNonSecureDbName, KSelectSql());

	TheTest.Printf(_L("DBMS, delete, UTF16 SQL strings, non-secure db, server\r\n"));

	DeleteTest(EServerDbTest, TheNonSecureDbName, KDeleteSql(), ECompactAtEnd);

	PrintFileSize(TheNonSecureDbName);

	//======================================================================================================

	CleanupStack::PopAndDestroy(fm);

	}

//Usage: "t_dbperf1 [<drive letter>:]"

TInt E32Main()

	{

	TheTest.Title();

	CTrapCleanup* tc = CTrapCleanup::New();

	//Construct test database file names, using the passed as an optional argument drive letter 

	TFileName fname;

	TParse parse;

	User::CommandLine(fname);

	_LIT(KNonSecureDbName, "c:\\test\\t_dbperf1_1.db");

	parse.Set(fname, &KNonSecureDbName, 0);

	const TDesC& dbFilePath1 = parse.FullName();

	TheNonSecureDbName.Copy(dbFilePath1);

	_LIT(KNonSecureDbName2, "c:\\test\\t_dbperf1_2.db");

	parse.Set(fname, &KNonSecureDbName2, 0);

	const TDesC& dbFilePath2 = parse.FullName();

	TheNonSecureDbName2.Copy(dbFilePath2);

	__UHEAP_MARK;

	TestEnvInit();

	TRAPD(err, DoTestsL());

	TestEnvDestroy();

	TEST2(err, KErrNone);

	__UHEAP_MARKEND;

	TheTest.End();

	TheTest.Close();

	delete tc;

	User::Heap().Check();

	return KErrNone;

	}