--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/tdbms/t_dbperf2.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1417 @@
+// 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 <d32dbms.h>
+#include <s32file.h>
+#include <e32test.h>
+#include <e32math.h>
+#include <s32mem.h>
+#include <hal.h>
+
+static RTest TheTest(_L("t_dbperf2"));
+static CTrapCleanup* TheTrapCleanup;
+static RFs TheFs;
+static RDbs TheDbs;
+static RDbNamedDatabase TheDatabase;
+static RDbRowSet TheRowSet;
+static RFile TheTestFile;
+static TFileName TheDatabaseFileName;
+static TFileName TheLogFileName;
+static TFileName TheTestFileName;
+static TParse TheParse;
+
+#define COUNT_OF(array) (sizeof(array)/sizeof(array[0]))
+
+const TInt KTestRecordCount = 400;
+
+const TInt KTextColSize = 200;//Change KCreateTestTableSql string too!
+
+_LIT(KCreateTestTableSql, "CREATE TABLE A(I1 INTEGER, I2 DOUBLE, I3 VARCHAR(200))");
+_LIT(KCreateIndexSql, "CREATE UNIQUE INDEX IDX ON A(I1)");
+
+const TInt KColSize2 = 500;
+_LIT(KCreateTestTableSql2, "CREATE TABLE A(I1 INTEGER, I2 LONG VARCHAR, I3 LONG VARBINARY)");
+
+const TChar KBufChar('O');
+TBuf8<KColSize2> TheBinRndData;
+TBuf16<KColSize2> TheTextRndData;
+
+//////////////////////////////////////////////////////
+
+static TInt TheCounterFreq = -10000000;
+const TInt KMicroSecIn1Sec = 1000000;
+
+TUint32 CalcTickDiff(TUint32 aStartTicks, TUint32 aEndTicks)
+	{
+	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;
+	if(diffTicks < 0)
+		{
+		diffTicks = KMaxTUint32 + diffTicks + 1;
+		}
+	return (TUint32)diffTicks;
+	}
+
+//Prints aFastCount parameter (converted to us)
+void PrintFcDiffAsUs(const TDesC& aFormatStr, TUint32 aFastCount)
+	{
+	double v = ((double)aFastCount * KMicroSecIn1Sec) / (double)TheCounterFreq;
+	TInt v2 = (TInt)v;
+	TheTest.Printf(aFormatStr, v2);
+	}
+
+//Prints aFastCount parameter (converted to us) and the records count
+void PrintFcDiffAsUs2(const TDesC& aFormatStr, TInt aRecCnt, TUint32 aFastCount)
+	{
+	double v = ((double)aFastCount * KMicroSecIn1Sec) / (double)TheCounterFreq;
+	TInt v2 = (TInt)v;
+	TheTest.Printf(aFormatStr, aRecCnt, v2);
+	}
+
+//////////////////////////////////////////////////////
+
+enum TRowSetType {EViewRowSet, ETableRowSet};
+const TRowSetType KRowSetTypes[] = {EViewRowSet/*, ETableRowSet*/}; //Excluding ETableRowSet means that the test requires less time.
+const TPtrC KRowSetTypeStr[] = {_L("RDbView.")/*, _L("RDbTable.")*/};//The coverage is not affected that much.
+
+//////////////////////////////////////////////////////
+
+const RDbRowSet::TAccess KAccessModes[] = {RDbRowSet::EInsertOnly, RDbRowSet::EUpdatable};
+const TPtrC KAccessModeStr[] = {_L("Insert only."), _L("Updatable.")};
+
+//////////////////////////////////////////////////////
+
+enum TUpdDirection {EUpdBackward, EUpdForward};
+const TUpdDirection KUpdDirectionTypes[] = {EUpdBackward, EUpdForward};
+const TPtrC KUpdDirectionTypeStr[] = {_L("Backward."), _L("Forward.")};
+
+//////////////////////////////////////////////////////
+
+enum TCommitRecCnt {ECommit_1_Rec = 1, ECommit_Cnt_Rec = 20, ECommit_All_Rec = KTestRecordCount};
+const TCommitRecCnt KCommitTypes[] = {ECommit_1_Rec, ECommit_Cnt_Rec, ECommit_All_Rec};
+const TPtrC KCommitTypeStr[] = {_L("Commit after 1 op."), _L("Commit after 20 ops."), _L("Commit at end.")};
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+//Delete "aFullName" file.
+static void DeleteFile(const TDesC& aFullName)
+	{
+	RFs fsSession;
+	TInt err = fsSession.Connect();
+	if(err == KErrNone)
+		{
+		TEntry entry;
+		if(fsSession.Entry(aFullName, entry) == KErrNone)
+			{
+			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
+			if(err != KErrNone) 
+				{
+				TheTest.Printf(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
+				}
+			err = fsSession.Delete(aFullName);
+			if(err != KErrNone) 
+				{
+				TheTest.Printf(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
+				}
+			}
+		fsSession.Close();
+		}
+	else
+		{
+		TheTest.Printf(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
+		}
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+static void CloseAll()
+	{
+	TheRowSet.Close();
+	TheDatabase.Close();
+	TheDbs.Close();
+	TheTestFile.Close();
+	TheFs.Close();
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
+//Tests macros and functions.
+//If (!aValue) then the test will be panicked, the test data files will be deleted.
+static void Check(TInt aValue, TInt aLine)
+	{
+	if(!aValue)
+		{
+		CloseAll();
+		DeleteFile(TheDatabaseFileName);
+		DeleteFile(TheTestFileName);
+		TheTest(EFalse, aLine);
+		}
+	}
+//If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.
+static void Check(TInt aValue, TInt aExpected, TInt aLine)
+	{
+	if(aValue != aExpected)
+		{
+		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
+		CloseAll();
+		DeleteFile(TheDatabaseFileName);
+		DeleteFile(TheTestFileName);
+		TheTest(EFalse, aLine);
+		}
+	}
+//Use these to test conditions.
+#define TEST(arg) ::Check((arg), __LINE__)
+#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void PrintFileSize()
+	{
+	RDbDatabase::TSize s = TheDatabase.Size();
+	TheTest.Printf(_L("####FileSize: %d\r\n"), s.iSize);
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void DbRowSetInsertTestL(TRowSetType aRowSetType, RDbRowSet::TAccess aAccessMode, TCommitRecCnt aCommitRecCnt)
+	{
+	TBuf<KTextColSize> textColVal;
+	for(TInt ii=23000;ii<(23000+KTextColSize);++ii)
+		{
+		textColVal.Append(TChar(ii));
+		}
+	for(TInt compaction=0;compaction<2;++compaction)
+		{
+		TheTest.Printf(compaction ? _L("Compaction:Yes.\r\n") : _L("Compaction:No.\r\n"));
+		TheRowSet.Close();
+		TInt err;
+		err = TheDatabase.Execute(_L("DELETE FROM A"));
+		TEST(err >= 0);
+		TUint32 fc = User::FastCounter();
+		if(aRowSetType == EViewRowSet)
+			{
+			RDbView view;
+			err = view.Prepare(TheDatabase, _L("SELECT * FROM A"), aAccessMode);
+			TEST2(err, KErrNone);
+			err = view.EvaluateAll();
+			TEST2(err, KErrNone);
+			TheRowSet = view;
+			}
+		else
+			{
+			RDbTable tbl;
+			err = tbl.Open(TheDatabase, _L("A"), aAccessMode);
+			TEST2(err, KErrNone);
+			TheRowSet = tbl;
+			}
+		TUint32 prepFc = CalcTickDiff(fc, User::FastCounter());
+		TUint32 insFc = 0;
+		TUint32 setcolFc = 0;
+		TUint32 putFc = 0;
+		TUint32 commitFc = 0;
+		TUint32 totalFc = 0;
+		fc = User::FastCounter();
+		for(TInt i=0,count=0;i<KTestRecordCount;++i)
+			{
+			TUint32 tmpFc;
+			if(aCommitRecCnt != ECommit_1_Rec && count == 0)
+				{
+				tmpFc = User::FastCounter();
+				err = TheDatabase.Begin();	
+				TEST2(err, KErrNone);
+				commitFc += CalcTickDiff(tmpFc, User::FastCounter());
+				}
+			tmpFc = User::FastCounter();
+			TheRowSet.InsertL();
+			insFc += CalcTickDiff(tmpFc, User::FastCounter());
+			tmpFc = User::FastCounter();
+			TheRowSet.SetColL(1, i);
+			TheRowSet.SetColL(2, i * 10.1234);
+			TheRowSet.SetColL(3, textColVal);
+			setcolFc += CalcTickDiff(tmpFc, User::FastCounter());
+			tmpFc = User::FastCounter();
+			TheRowSet.PutL();
+			putFc += CalcTickDiff(tmpFc, User::FastCounter());
+			if(aCommitRecCnt != ECommit_1_Rec && ++count == aCommitRecCnt)
+				{
+				tmpFc = User::FastCounter();
+				count = 0;
+				err = TheDatabase.Commit();	
+				TEST2(err, KErrNone);
+				commitFc += CalcTickDiff(tmpFc, User::FastCounter());
+				if(compaction)
+					{
+					err = TheDatabase.Compact();
+					TEST2(err, KErrNone);
+					}
+				}
+			}
+		totalFc = CalcTickDiff(fc, User::FastCounter());
+		PrintFcDiffAsUs(_L("###Prepare,time=%d us\r\n"), prepFc);
+		PrintFcDiffAsUs(_L("###InsertL,time=%d us\r\n"), insFc);
+		PrintFcDiffAsUs(_L("###SetColL,time=%d us\r\n"), setcolFc);
+		PrintFcDiffAsUs(_L("###PutL,   time=%d us\r\n"), putFc);
+		PrintFcDiffAsUs(_L("###Commit, time=%d us\r\n"), commitFc);
+		PrintFcDiffAsUs(_L("###Total,  time=%d us\r\n"), totalFc);
+		TheRowSet.Close();
+		PrintFileSize();
+		//Check
+		if(aAccessMode != RDbRowSet::EInsertOnly)
+			{
+			RDbView view;
+			err = view.Prepare(TheDatabase, _L("SELECT * FROM A"), aAccessMode);
+			TEST2(err, KErrNone);
+			err = view.EvaluateAll();
+			TEST2(err, KErrNone);
+			TInt count = view.CountL();
+			view.Close();
+			TEST2(count, KTestRecordCount);
+			}
+		}//end of - for(TInt compaction=0;compaction<2;++compaction)
+	}
+
+void FirstRecL(TUpdDirection aUpdDirection)
+	{
+	TBool rc = EFalse;
+	switch(aUpdDirection)
+		{
+		case EUpdBackward:
+			rc = TheRowSet.LastL();
+			break;
+		case EUpdForward:
+		default:
+			rc = TheRowSet.FirstL();
+			break;
+		}
+	TEST(rc);
+	}
+
+void NextRecL(TUpdDirection aUpdDirection)
+	{
+	TBool rc = EFalse;
+	switch(aUpdDirection)
+		{
+		case EUpdBackward:
+			rc = TheRowSet.PreviousL();
+			break;
+		case EUpdForward:
+		default:
+			rc = TheRowSet.NextL();
+			break;
+		}
+	TEST(rc);
+	}
+
+void DbRowSetUpdateTestL(TRowSetType aRowSetType, TUpdDirection aUpdDirection, TCommitRecCnt aCommitRecCnt)
+	{
+	TBuf<KTextColSize> textColVal;
+	for(TInt ii=33000;ii<(33000+KTextColSize);++ii)
+		{
+		textColVal.Append(TChar(ii));
+		}
+		
+	for(TInt compaction=0;compaction<2;++compaction)
+		{
+		TheTest.Printf(compaction ? _L("Compaction:Yes.\r\n") : _L("Compaction:No.\r\n"));
+		TheRowSet.Close();
+		TInt err;
+		TUint32 fc = User::FastCounter();
+		if(aRowSetType == EViewRowSet)
+			{
+			RDbView view;
+			err = view.Prepare(TheDatabase, _L("SELECT * FROM A WHERE I1 >= 0 AND I1 <= 1000000"), RDbRowSet::EUpdatable);
+			TEST2(err, KErrNone);
+			err = view.EvaluateAll();
+			TEST2(err, KErrNone);
+			TheRowSet = view;
+			}
+		else
+			{
+			RDbTable tbl;
+			err = tbl.Open(TheDatabase, _L("A"), RDbRowSet::EUpdatable);
+			TEST2(err, KErrNone);
+			TheRowSet = tbl;
+			}
+		TInt cnt = TheRowSet.CountL();
+		TEST2(cnt, KTestRecordCount);
+		TUint32 prepFc = CalcTickDiff(fc, User::FastCounter());
+		TUint32 insFc = 0;
+		TUint32 setcolFc = 0;
+		TUint32 putFc = 0;
+		TUint32 commitFc = 0;
+		TUint32 totalFc = 0;
+		fc = User::FastCounter();
+		for(TInt i=0,count=0;i<KTestRecordCount;++i)
+			{
+			TRAP(err, (i == 0 ? FirstRecL(aUpdDirection) : NextRecL(aUpdDirection)));
+			TEST2(err, KErrNone);
+			TUint32 tmpFc;
+			if(aCommitRecCnt != ECommit_1_Rec && count == 0)
+				{
+				tmpFc = User::FastCounter();
+				err = TheDatabase.Begin();	
+				TEST2(err, KErrNone);
+				commitFc += CalcTickDiff(tmpFc, User::FastCounter());
+				}
+			tmpFc = User::FastCounter();
+			TheRowSet.UpdateL();
+			insFc += CalcTickDiff(tmpFc, User::FastCounter());
+			tmpFc = User::FastCounter();
+			TheRowSet.SetColL(2, i * 20.0);
+			TheRowSet.SetColL(3, textColVal);
+			setcolFc += CalcTickDiff(tmpFc, User::FastCounter());
+			tmpFc = User::FastCounter();
+			TheRowSet.PutL();
+			putFc += CalcTickDiff(tmpFc, User::FastCounter());
+			if(aCommitRecCnt != ECommit_1_Rec && ++count == aCommitRecCnt)
+				{
+				tmpFc = User::FastCounter();
+				count = 0;
+				err = TheDatabase.Commit();	
+				TEST2(err, KErrNone);
+				commitFc += CalcTickDiff(tmpFc, User::FastCounter());
+				if(compaction)
+					{
+					err = TheDatabase.Compact();
+					TEST2(err, KErrNone);
+					}
+				}
+			}
+		totalFc = CalcTickDiff(fc, User::FastCounter());
+		PrintFcDiffAsUs(_L("###Prepare,time=%d us\r\n"), prepFc);
+		PrintFcDiffAsUs(_L("###UpdateL,time=%d us\r\n"), insFc);
+		PrintFcDiffAsUs(_L("###SetColL,time=%d us\r\n"), setcolFc);
+		PrintFcDiffAsUs(_L("###PutL,   time=%d us\r\n"), putFc);
+		PrintFcDiffAsUs(_L("###Commit, time=%d us\r\n"), commitFc);
+		PrintFcDiffAsUs(_L("###Total,  time=%d us\r\n"), totalFc);
+		TheRowSet.Close();
+		PrintFileSize();
+		}//end of - for(TInt compaction=0;compaction<2;++compaction)
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void CreateDatabase()
+	{
+	TInt err = TheDatabase.Replace(TheFs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	TheDatabase.Close();
+	err = TheDbs.Connect();
+	TEST2(err, KErrNone);
+	err = TheDatabase.Open(TheDbs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	err = TheDatabase.Execute(KCreateTestTableSql);
+	TEST2(err, KErrNone);
+	err = TheDatabase.Execute(KCreateIndexSql);
+	TEST2(err, KErrNone);
+	}
+
+void CreateAndFillDatabase()
+	{
+	TInt err = TheDatabase.Replace(TheFs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	TheDatabase.Close();
+	err = TheDbs.Connect();
+	TEST2(err, KErrNone);
+	err = TheDatabase.Open(TheDbs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	err = TheDatabase.Execute(KCreateTestTableSql);
+	TEST2(err, KErrNone);
+	err = TheDatabase.Execute(KCreateIndexSql);
+	TEST2(err, KErrNone);
+	//	
+	TBuf<KTextColSize> textColVal;
+	for(TInt ii=23000;ii<(23000+KTextColSize);++ii)
+		{
+		textColVal.Append(TChar(ii));
+		}
+	err = TheDatabase.Begin();	
+	TEST2(err, KErrNone);
+	for(TInt i=0;i<KTestRecordCount;++i)
+		{
+		TBuf<KTextColSize + 100> sql;
+		sql.Format(_L("INSERT INTO A(I1,I2,I3) VALUES(%d,%d,'%S')"), i, i + 100000, &textColVal);
+		err = TheDatabase.Execute(sql);
+		TEST2(err, 1);
+		}
+	err = TheDatabase.Commit();	
+	TEST2(err, KErrNone);
+	}
+
+void DestroyDatabase()
+	{
+	TheRowSet.Close();
+	TheDatabase.Close();
+	TheDbs.Close();
+	TInt err = TheFs.Delete(TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	}
+
+void GetFastCounterFrequency()
+	{
+	TheTest.Start(_L("Get fast counter frequency"));
+	TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);
+	TheTest.Printf(_L("Counter frequency=%d\r\n"), TheCounterFreq);
+	}
+	
+void FileBlockSizeTestsL()
+	{
+	TheTest.Next(_L("File Block Size test"));
+	
+	const TInt KBlockSizeLow = 64, KBlockSizeHigh = 1024 * 64;
+	for(TInt blockSize=KBlockSizeLow;blockSize<=KBlockSizeHigh;blockSize*=2)
+		{
+		for(TInt addSize=-4;addSize<=4;addSize+=4)
+			{
+			TInt currBlockSize = blockSize + addSize;
+			TBuf<100> title;
+			title.Copy(_L("File block size "));
+			title.AppendNum((TInt64)currBlockSize);
+			title.Append(_L(" bytes"));
+			TheTest.Printf(title);
+			
+			HBufC8* data = HBufC8::New(currBlockSize);
+			TEST(data != NULL);
+			TPtr8 dataPtr = data->Des();
+			dataPtr.SetLength(currBlockSize);
+			
+			TInt err = TheTestFile.Replace(TheFs, TheTestFileName, EFileRead | EFileWrite);
+			TEST2(err, KErrNone);
+			err = TheTestFile.Write(dataPtr);
+			TEST2(err, KErrNone);
+			err = TheTestFile.Flush();
+			TEST2(err, KErrNone);
+			TUint32 fc = User::FastCounter();
+			err = TheTestFile.Write(0, dataPtr);
+			fc = CalcTickDiff(fc, User::FastCounter());
+			PrintFcDiffAsUs(_L("###Time=%d us\r\n"), fc);
+			TEST2(err, KErrNone);
+			TheTestFile.Close();
+			
+			delete data;
+			}
+		}
+	DeleteFile(TheTestFileName);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-DBMS-UT-3310
+@SYMTestCaseDesc        DBMS, RDbView performance tests.
+@SYMTestPriority        High
+@SYMTestActions        	The test creates and fills a test table with integer, real and text column. Then
+						executes 3 test subcases:
+						- updates the integer column only in all records, using "SELECT I1,I2,I3" cursor;
+						- updates the text column only in all records, using "SELECT I1,I2,I3" cursor;
+						- updates all columns in all records, using "SELECT I1,I2,I3" cursor;
+						The execution times are printed out.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ7141
+*/
+void RecordLenTestL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3310 Record length test - create database"));
+	CreateAndFillDatabase();
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////	
+	TheTest.Printf(_L("Record length test - update the integer column only"));
+	TUint32 fc = User::FastCounter();
+	RDbView view;
+	TInt err = view.Prepare(TheDatabase, _L("SELECT * FROM A"));
+	TEST2(err, KErrNone);
+	err = view.EvaluateAll();
+	TEST2(err, KErrNone);
+	TheRowSet = view;
+	err = TheDatabase.Begin();
+	TEST2(err, KErrNone);
+	TInt recCnt = 0;
+	TheRowSet.FirstL();
+	do
+		{
+		TheRowSet.UpdateL();
+		TheRowSet.SetColL(1, 60000 + recCnt);
+		TheRowSet.PutL();
+		++recCnt;
+		}
+	while(TheRowSet.NextL());
+	TEST2(recCnt, KTestRecordCount);
+	err = TheDatabase.Commit();
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###Time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
+	TheRowSet.Close();
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////	
+	TheTest.Printf(_L("Record length test - update the text column only"));
+	fc = User::FastCounter();
+	err = view.Prepare(TheDatabase, _L("SELECT * FROM A"));
+	TEST2(err, KErrNone);
+	err = view.EvaluateAll();
+	TEST2(err, KErrNone);
+	TheRowSet = view;
+	err = TheDatabase.Begin();
+	TEST2(err, KErrNone);
+	recCnt = 0;
+	TheRowSet.FirstL();
+	do
+		{
+		TheRowSet.UpdateL();
+		TheRowSet.SetColL(3, _L("0123456789"));
+		TheRowSet.PutL();
+		++recCnt;
+		}
+	while(TheRowSet.NextL());
+	TEST2(recCnt, KTestRecordCount);
+	err = TheDatabase.Commit();
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###Time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
+	TheRowSet.Close();
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////	
+	TheTest.Printf(_L("Record length test - update all columns"));
+	fc = User::FastCounter();
+	err = view.Prepare(TheDatabase, _L("SELECT * FROM A"));
+	TEST2(err, KErrNone);
+	err = view.EvaluateAll();
+	TEST2(err, KErrNone);
+	TheRowSet = view;
+	err = TheDatabase.Begin();
+	TEST2(err, KErrNone);
+	recCnt = 0;
+	TheRowSet.FirstL();
+	do
+		{
+		TheRowSet.UpdateL();
+		TheRowSet.SetColL(1, 34567 - recCnt);
+		TheRowSet.SetColL(2, 888.111);
+		TheRowSet.SetColL(3, _L("QWETYUIOPASDF"));
+		TheRowSet.PutL();
+		++recCnt;
+		}
+	while(TheRowSet.NextL());
+	TEST2(recCnt, KTestRecordCount);
+	err = TheDatabase.Commit();
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###Time=%d ms\r\n"), CalcTickDiff(fc, User::FastCounter()));
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////	
+	DestroyDatabase();//This will destroy TheRowSet object too.
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-DBMS-UT-3311
+@SYMTestCaseDesc        DBMS, RDbView performance tests.
+@SYMTestPriority        High
+@SYMTestActions        	The test measures the time used by insert-only or updatable cursor to:
+						- insert certain amount of records, comitting after each insert;
+						- insert certain amount of records, comitting after 20 inserts;
+						- insert certain amount of records, comitting at the end;
+						All cases repeated with and without compaction (except the first one).
+						The execution times are printed out.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ7141
+*/
+void InsertTestsL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3311 RDbView \"insert\" performance tests")); 	
+	for(TInt i1=0;i1<COUNT_OF(KRowSetTypes);++i1)
+		{
+		for(TInt i2=0;i2<COUNT_OF(KAccessModes);++i2)
+			{
+			for(TInt i3=0;i3<COUNT_OF(KCommitTypes);++i3)
+				{
+				CreateDatabase();
+				TBuf<200> title;
+				title.Copy(_L("Insert."));
+				title.Append(KRowSetTypeStr[i1]);
+				title.Append(KAccessModeStr[i2]);
+				title.Append(KCommitTypeStr[i3]);
+				TheTest.Printf(title);
+				DbRowSetInsertTestL(KRowSetTypes[i1], KAccessModes[i2], KCommitTypes[i3]);
+				DestroyDatabase();
+				}
+			}
+		}
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-DBMS-UT-3312
+@SYMTestCaseDesc        DBMS, RDbView performance tests.
+@SYMTestPriority        High
+@SYMTestActions        	The test measures the time used by updatable cursor to:
+						- update (moving forward/backward) certain amount of records, comitting after each update;
+						- update (moving forward/backward) certain amount of records, comitting after 20 update;
+						- update (moving forward/backward) certain amount of records, comitting at the end;
+						All cases repeated with and without compaction (except the first one).
+						The execution times are printed out.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ7141
+*/
+void UpdateTestsL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3312 RDbView \"update\" performance tests")); 	
+	for(TInt i1=0;i1<COUNT_OF(KRowSetTypes);++i1)
+		{
+		for(TInt i2=0;i2<COUNT_OF(KUpdDirectionTypes);++i2)
+			{
+			for(TInt i3=0;i3<COUNT_OF(KCommitTypes);++i3)
+				{
+				CreateAndFillDatabase();
+				TBuf<200> title;
+				title.Copy(_L("Update."));
+				title.Append(KRowSetTypeStr[i1]);
+				title.Append(KUpdDirectionTypeStr[i2]);
+				title.Append(KCommitTypeStr[i3]);
+				TheTest.Printf(title);
+				DbRowSetUpdateTestL(KRowSetTypes[i1], KUpdDirectionTypes[i2], KCommitTypes[i3]);
+				DestroyDatabase();
+				}
+			}
+		}
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-DBMS-UT-3313
+@SYMTestCaseDesc        DBMS, RDbDatabase::Execute() performance tests.
+@SYMTestPriority        High
+@SYMTestActions        	The test measures the time used by RDbDatabase::Execute() to:
+						- insert certain amount of records, comitting after each insert;
+						- insert certain amount of records, comitting after 20 inserts;
+						- insert certain amount of records, comitting at the end;
+						All cases repeated with and without compaction (except the first one).
+						The execution times are printed out.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ7141
+*/
+void DbInsertTestsL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3313 RDbDatabase::Execute() \"insert\" performance tests")); 	
+	TBuf<KTextColSize> textColVal;
+	for(TInt ii=23000;ii<(23000+KTextColSize);++ii)
+		{
+		textColVal.Append(TChar(ii));
+		}
+	for(TInt compaction=0;compaction<2;++compaction)
+		{
+		for(TInt i3=0;i3<COUNT_OF(KCommitTypes);++i3)
+			{
+			CreateDatabase();
+			TBuf<200> title;
+			title.Copy(_L("RDbDatabase::Execute().Insert."));
+			title.Append(KCommitTypeStr[i3]);
+			title.Append(compaction ? _L("Compaction:Yes.") : _L("Compaction:No."));
+			TheTest.Printf(title);
+			TInt count = 0, err = KErrNone;
+			TUint32 fc = User::FastCounter();
+			for(TInt i=0;i<KTestRecordCount;++i)
+				{
+				if(KCommitTypes[i3] != ECommit_1_Rec && count == 0)
+					{
+					err = TheDatabase.Begin();	
+					TEST2(err, KErrNone);
+					}
+				TBuf<KTextColSize + 100> sql;
+				sql.Format(_L("INSERT INTO A(I1,I2,I3) VALUES(%d,%d,'%S')"), i, i + 100000, &textColVal);
+				err = TheDatabase.Execute(sql);
+				TEST2(err, 1);
+				if(KCommitTypes[i3] != ECommit_1_Rec && ++count == KCommitTypes[i3])
+					{
+					count = 0;
+					err = TheDatabase.Commit();	
+					TEST2(err, KErrNone);
+					if(compaction)
+						{
+						err = TheDatabase.Compact();
+						TEST2(err, KErrNone);
+						}
+					}
+				}
+			PrintFcDiffAsUs(_L("###RDbDatabase::Execute(), Time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
+			PrintFileSize();
+			DestroyDatabase();
+			}
+		}
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-DBMS-UT-3314
+@SYMTestCaseDesc        DBMS, RDbDatabase::Execute() performance tests.
+@SYMTestPriority        High
+@SYMTestActions        	The test measures the time used by RDbDatabase::Execute() to:
+						- update certain amount of records, comitting after each update;
+						- update certain amount of records, comitting after 20 updates;
+						- update certain amount of records, comitting at the end;
+						All cases repeated with and without compaction (except the first one).
+						The execution times are printed out.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ7141
+*/
+void DbUpdateTestsL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3314 RDbDatabase::Execute() \"update\" performance tests")); 	
+	TBuf<KTextColSize> textColVal;
+	for(TInt ii=43000;ii<(43000+KTextColSize);++ii)
+		{
+		textColVal.Append(TChar(ii));
+		}
+	for(TInt compaction=0;compaction<2;++compaction)
+		{
+		for(TInt i3=0;i3<COUNT_OF(KCommitTypes);++i3)
+			{
+			CreateAndFillDatabase();
+			TBuf<200> title;
+			title.Copy(_L("RDbDatabase::Execute().Update."));
+			title.Append(KCommitTypeStr[i3]);
+			title.Append(compaction ? _L("Compaction:Yes.") : _L("Compaction:No."));
+			TheTest.Printf(title);
+			TInt count = 0, err = KErrNone;
+			TUint32 fc = User::FastCounter();
+			for(TInt i=0;i<KTestRecordCount;++i)
+				{
+				if(KCommitTypes[i3] != ECommit_1_Rec && count == 0)
+					{
+					err = TheDatabase.Begin();	
+					TEST2(err, KErrNone);
+					}
+				TBuf<KTextColSize + 100> sql;
+				sql.Format(_L("UPDATE A SET I2=%d,I3='%S' WHERE I1=%d"), i + 556622, &textColVal, i);
+				err = TheDatabase.Execute(sql);
+				TEST2(err, 1);
+				if(KCommitTypes[i3] != ECommit_1_Rec && ++count == KCommitTypes[i3])
+					{
+					count = 0;
+					err = TheDatabase.Commit();	
+					TEST2(err, KErrNone);
+					if(compaction)
+						{
+						err = TheDatabase.Compact();
+						TEST2(err, KErrNone);
+						}
+					}
+				}
+			PrintFcDiffAsUs(_L("###RDbDatabase::Execute(), Time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
+			PrintFileSize();
+			DestroyDatabase();
+			}
+		}
+	}
+
+/**
+@SYMTestCaseID			PDS-DBMS-UT-4010
+@SYMTestCaseDesc		Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+						Tests the performance of RDbColWriteStream::OpenLC() and RDbColWriteStream::OpenL(). 
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF141419
+*/
+void DbColWriteStreamTestsL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-DBMS-UT-4010 RDbColWriteStream performance test")); 	
+	
+	TInt err = TheDatabase.Replace(TheFs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	err = TheDatabase.Execute(KCreateTestTableSql2);
+	TEST(err >= 0);
+
+	RDbView view;
+	err = view.Prepare(TheDatabase, _L("select * from A"), view.EInsertOnly);
+	TEST2(err, KErrNone);
+	TheRowSet = view;	
+
+	CDbColSet* colSet = TheRowSet.ColSetL();
+	const TDbColNo KIdx1 = colSet->ColNo(_L("I1"));
+	const TDbColNo KIdx2 = colSet->ColNo(_L("I2"));
+	const TDbColNo KIdx3 = colSet->ColNo(_L("I3"));
+	delete colSet;
+	
+	TheTextRndData.SetLength(KColSize2);
+	TheTextRndData.Fill(KBufChar);
+	TheBinRndData.SetLength(KColSize2);
+	TheBinRndData.Fill(KBufChar);
+
+	err = TheDatabase.Begin();
+	TEST2(err, KErrNone);
+	
+	TUint32 openLcFc = 0;
+	TUint32 openLFc = 0;
+	TUint32 fc = User::FastCounter();
+	
+	for(TInt i=0;i<KTestRecordCount;++i)
+		{
+		TheRowSet.InsertL();
+		TheRowSet.SetColL(KIdx1, i + 1);
+		
+		RDbColWriteStream strm1;
+		TUint32 tmp = User::FastCounter();
+		strm1.OpenLC(TheRowSet, KIdx2);
+		openLcFc += CalcTickDiff(tmp, User::FastCounter());
+		strm1.WriteL(TheTextRndData, KColSize2);
+		strm1.CommitL();
+		CleanupStack::PopAndDestroy(&strm1);
+
+		RDbColWriteStream strm2;
+		CleanupClosePushL(strm2);
+		tmp = User::FastCounter();
+		strm2.OpenL(TheRowSet, KIdx3);
+		openLFc += CalcTickDiff(tmp, User::FastCounter());
+		strm2.WriteL(TheBinRndData, KColSize2);
+		strm2.CommitL();
+		CleanupStack::PopAndDestroy(&strm2);
+		
+		TheRowSet.PutL();
+		}
+	
+	PrintFcDiffAsUs2(_L("###RDbColWriteStream, write %3d records, Time=%d us\r\n"), 
+										KTestRecordCount, CalcTickDiff(fc, User::FastCounter()));
+	PrintFcDiffAsUs (_L("###OpenLC()                            , Time=%d us\r\n"), openLcFc);
+	PrintFcDiffAsUs (_L("###OpenL()                             , Time=%d us\r\n"), openLFc);
+	
+	TheRowSet.Close();
+	
+	err = TheDatabase.Commit();
+	TEST2(err, KErrNone);
+	
+	TheDatabase.Close();
+	}
+
+/**
+@SYMTestCaseID			PDS-DBMS-UT-4011
+@SYMTestCaseDesc		Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+						Tests the performance of RDbColReadStream::OpenLC() and RDbColReadStream::OpenL(). 
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF141419
+*/
+void DbColReadStreamTestsL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-DBMS-UT-4011 RDbColReadStream performance test")); 	
+	
+	TInt err = TheDatabase.Open(TheFs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+
+	RDbView view;
+	err = view.Prepare(TheDatabase, _L("select * from A"), view.EReadOnly);
+	TEST2(err, KErrNone);
+	TheRowSet = view;	
+
+	err = view.EvaluateAll();
+	TEST2(err, KErrNone);
+	
+	CDbColSet* colSet = TheRowSet.ColSetL();
+	const TDbColNo KIdx1 = colSet->ColNo(_L("I1"));
+	const TDbColNo KIdx2 = colSet->ColNo(_L("I2"));
+	const TDbColNo KIdx3 = colSet->ColNo(_L("I3"));
+	delete colSet;
+
+	TBuf8<KColSize2> binData;
+	TBuf16<KColSize2> textData;
+	
+	TInt recCnt = 0;
+	TUint32 openLcFc = 0;
+	TUint32 openLFc = 0;
+	TUint32 fc = User::FastCounter();
+
+	if(TheRowSet.FirstL())
+		{
+		do
+			{
+			TheRowSet.GetL();
+			++recCnt;
+			
+			TInt i1 = TheRowSet.ColInt(KIdx1);
+			TEST2(recCnt, i1);
+			
+			RDbColReadStream strm1;
+			TUint32 tmp = User::FastCounter();
+			strm1.OpenLC(TheRowSet, KIdx2);
+			openLcFc += CalcTickDiff(tmp, User::FastCounter());
+			strm1.ReadL(textData, KColSize2);
+			CleanupStack::PopAndDestroy(&strm1);
+			TEST(textData == TheTextRndData);
+				
+			RDbColReadStream strm2;
+			CleanupClosePushL(strm2);
+			tmp = User::FastCounter();
+			strm2.OpenL(TheRowSet, KIdx3);
+			openLFc += CalcTickDiff(tmp, User::FastCounter());
+			strm2.ReadL(binData, KColSize2);
+			CleanupStack::PopAndDestroy(&strm2);
+			TEST(binData == TheBinRndData);
+			} while(TheRowSet.NextL());
+		}
+	TEST2(recCnt, KTestRecordCount);
+	
+	PrintFcDiffAsUs2(_L("###RDbColReadStream, read %3d records, Time=%d us\r\n"), 
+			                                 recCnt, CalcTickDiff(fc, User::FastCounter()));
+	PrintFcDiffAsUs (_L("###OpenLC()                          , Time=%d us\r\n"), openLcFc);
+	PrintFcDiffAsUs (_L("###OpenL()                           , Time=%d us\r\n"), openLFc);
+	
+	TheRowSet.Close();
+	
+	TheDatabase.Close();
+	}
+
+/**
+@SYMTestCaseID			PDS-DBMS-UT-4012
+@SYMTestCaseDesc		Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+						RDbUpdate performance tests.
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF141419
+*/
+void DbUpdateTestL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-DBMS-UT-4012 RDbUpdate performance test")); 	
+	
+	TInt err = TheDbs.Connect();
+	TEST2(err, KErrNone);
+		
+	err = TheDatabase.Open(TheDbs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	
+	TUint32 execFc = 0;
+	TUint32 nextFc = 0;
+	TUint32 rowCntFc = 0;
+	
+	//Synchronous update
+	TInt recCnt = 0;
+	RDbUpdate upd1;
+	TUint32 fc = User::FastCounter();
+	err = upd1.Execute(TheDatabase, _L("UPDATE A SET I1=1000, I2='8888888888888888'"));
+	execFc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, KErrNone);
+	TUint32 tmp = User::FastCounter();
+	while((err = upd1.Next()) > 0)
+		{
+		}
+	nextFc = CalcTickDiff(tmp, User::FastCounter());
+	tmp = User::FastCounter();
+	recCnt = upd1.RowCount();
+	rowCntFc = CalcTickDiff(tmp, User::FastCounter());
+	upd1.Close();
+	fc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, 0);
+	TEST2(recCnt, KTestRecordCount);
+	
+	TheDatabase.Close();
+
+	PrintFcDiffAsUs2(_L("###Sync RDbUpdate, %3d records, Time=%d us\r\n"), recCnt, fc);
+	PrintFcDiffAsUs (_L("###Execute()                  , Time=%d us\r\n"), execFc);
+	PrintFcDiffAsUs (_L("###Next()                     , Time=%d us\r\n"), nextFc);
+	PrintFcDiffAsUs (_L("###RowCount()                 , Time=%d us\r\n"), rowCntFc);
+	
+	//Asynchronous update
+	err = TheDatabase.Open(TheDbs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	
+	execFc = 0;
+	nextFc = 0;
+	rowCntFc = 0;
+	recCnt = 0;
+	
+	RDbUpdate upd2;
+	fc = User::FastCounter();
+	err = upd2.Execute(TheDatabase, _L("UPDATE A SET I1=5678, I2='9w27u22272252542r2242242424221'"));
+	execFc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, KErrNone);
+	TRequestStatus stat;
+	tmp = User::FastCounter();
+	do
+		{
+		upd2.Next(stat);
+		User::WaitForRequest(stat);
+		} while(stat.Int() > 0);
+	nextFc = CalcTickDiff(tmp, User::FastCounter());
+	tmp = User::FastCounter();
+	recCnt = upd2.RowCount();
+	rowCntFc = CalcTickDiff(tmp, User::FastCounter());
+	upd2.Close();
+	fc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(stat.Int(), 0);
+	TEST2(recCnt, KTestRecordCount);
+
+	TheDatabase.Close();
+	
+	PrintFcDiffAsUs2(_L("###Async RDbUpdate, %3d records, Time=%d us\r\n"), recCnt, fc);
+	PrintFcDiffAsUs (_L("###Execute()                   , Time=%d us\r\n"), execFc);
+	PrintFcDiffAsUs (_L("###Next()                      , Time=%d us\r\n"), nextFc);
+	PrintFcDiffAsUs (_L("###RowCount()                  , Time=%d us\r\n"), rowCntFc);
+	
+	TheDbs.Close();
+	err = TheFs.Delete(TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	}
+
+/**
+@SYMTestCaseID			PDS-DBMS-UT-4013
+@SYMTestCaseDesc		Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+						RDbStoreDatabase performance tests.
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF141419
+*/
+void DbStoreDatabaseTestL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-DBMS-UT-4013 RDbStoreDatabase performance test")); 	
+	
+	CFileStore* fstore = CPermanentFileStore::ReplaceLC(TheFs, TheDatabaseFileName, EFileRead | EFileWrite);
+	fstore->SetTypeL(fstore->Layout());
+	
+	//Create the database, insert records, compress the store.
+	
+	RDbStoreDatabase db1;
+	CleanupClosePushL(db1);
+	TUint32 fc = User::FastCounter();
+	TStreamId strmId = db1.CreateL(fstore);
+	TUint32 createFc = CalcTickDiff(fc, User::FastCounter());
+	
+	TInt err = db1.Execute(KCreateTestTableSql2);
+	TEST(err >= 0);
+	err = db1.Begin();
+	TEST2(err, 0);
+	for(TInt i=0;i<KTestRecordCount;++i)
+		{
+		err = db1.Execute(_L("INSERT INTO A(I1, I2) VALUES(1, 'ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZAAAAAAAAAAAAAAAAAAAAAAAAAAAA')"));
+		TEST2(err, 1);
+		}
+	err = db1.Commit();
+	TEST2(err, 0);
+
+	CleanupStack::PopAndDestroy(&db1);
+	TUint32 writeFc = CalcTickDiff(fc, User::FastCounter());
+	
+	TInt fsize1 = 0;
+	err = fstore->File().Size(fsize1);
+	TEST2(err, KErrNone);
+	
+	fc = User::FastCounter();
+	RDbStoreDatabase::CompressL(*fstore, strmId);
+	TUint32 compressFc = CalcTickDiff(fc, User::FastCounter());
+
+	TInt fsize2 = 0;
+	err = fstore->File().Size(fsize2);
+	TEST2(err, KErrNone);
+	
+	CleanupStack::PopAndDestroy(fstore);
+	
+	PrintFcDiffAsUs2(_L("###RDbStoreDatabase, write %3d records, Time=%d us\r\n"), KTestRecordCount, writeFc);
+	PrintFcDiffAsUs (_L("###CreateL()                          , Time=%d us\r\n"), createFc);
+	PrintFcDiffAsUs (_L("###CompressL()                        , Time=%d us\r\n"), compressFc);
+	
+	//Decompress the store, open the database, read the records
+
+	fstore = CPermanentFileStore::OpenLC(TheFs, TheDatabaseFileName, EFileRead | EFileWrite);
+	fstore->SetTypeL(fstore->Layout());
+	
+	fc = User::FastCounter();
+	RDbStoreDatabase::DecompressL(*fstore, strmId);
+	TUint32 decompressFc = CalcTickDiff(fc, User::FastCounter());
+
+	TInt fsize3 = 0;
+	err = fstore->File().Size(fsize3);
+	TEST2(err, KErrNone);
+	
+	RDbStoreDatabase db2;
+	CleanupClosePushL(db2);
+	fc = User::FastCounter();
+	db2.OpenL(fstore, strmId);
+	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
+	
+	RDbView view;
+	err = view.Prepare(db2, _L("SELECT * FROM A"));
+	TEST2(err, KErrNone);
+	err = view.EvaluateAll();
+	TEST2(err, KErrNone);	
+	TheRowSet = view;
+	
+	CDbColSet* colSet = TheRowSet.ColSetL();
+	const TDbColNo KIdx1 = colSet->ColNo(_L("I1"));
+	const TDbColNo KIdx2 = colSet->ColNo(_L("I2"));
+	const TDbColNo KIdx3 = colSet->ColNo(_L("I3"));
+	delete colSet;
+
+	TInt recCnt = 0;
+	if(TheRowSet.FirstL())
+		{
+		do
+			{
+			TheRowSet.GetL();
+			++recCnt;
+			
+			RDbColReadStream strm1;
+			strm1.OpenLC(TheRowSet, KIdx2);
+			TBuf<KColSize2> buf;
+			_LIT(KText, "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZAAAAAAAAAAAAAAAAAAAAAAAAAAAA");//the same as the used in the INSERT statement above
+			strm1.ReadL(buf, KText().Length());
+			CleanupStack::PopAndDestroy(&strm1);
+			TEST(KText() == buf);
+			} while(TheRowSet.NextL());
+		}
+	TEST2(recCnt, KTestRecordCount);
+	
+	TheRowSet.Close();
+	TUint32 readFc = CalcTickDiff(fc, User::FastCounter());
+	
+	CleanupStack::PopAndDestroy(&db2);
+	CleanupStack::PopAndDestroy(fstore);
+	
+	PrintFcDiffAsUs2(_L("###RDbStoreDatabase, read %3d records , Time=%d us\r\n"), recCnt, readFc);
+	PrintFcDiffAsUs (_L("###OpenL()                            , Time=%d us\r\n"), openFc);
+	PrintFcDiffAsUs (_L("###DecompressL()                      , Time=%d us\r\n"), decompressFc);
+	TheTest.Printf(_L("###File size. After write: %d. After Compress(): %d. After Decompress(): %d\r\n"), fsize1, fsize2, fsize3);
+	
+	err = TheFs.Delete(TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	}
+
+/**
+@SYMTestCaseID			PDS-DBMS-UT-4014
+@SYMTestCaseDesc		Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+						RDbDatabase performance tests.
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF141419 - DBMS, new performance tests - RDbUpdate, RDbStoreDatabase.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF141419
+*/
+void DbDatabaseTestL()
+	{
+	TheTest.Next(_L(" @SYMTestCaseID:PDS-DBMS-UT-4014 RDbDatabase performance test")); 	
+	
+	TInt err = TheDatabase.Replace(TheFs, TheDatabaseFileName);
+	TEST2(err, KErrNone);
+	
+	//CDbColSet
+	_LIT(KColName1, "Col1");
+	_LIT(KColName2, "Col2");
+	_LIT(KColName3, "Col3");
+	TUint32 fc = User::FastCounter();
+	CDbColSet* colset = CDbColSet::NewLC();
+	TDbCol col1(KColName1, EDbColInt32);
+	colset->AddL(col1);
+	TDbCol col2(KColName2, EDbColText16, 100);
+	colset->AddL(col2);
+	TDbCol col3(KColName3, EDbColBinary, 100);
+	colset->AddL(col3);
+	TUint32 colSetFc = CalcTickDiff(fc, User::FastCounter());
+	PrintFcDiffAsUs(_L("###CDbColSet::NewLC() & CDbColSet::AddL(), Time=%d us\r\n"), colSetFc);
+	
+	//RDbDatabase::CreateTable()
+	_LIT(KTblName, "ATbl");
+	fc = User::FastCounter();
+	err = TheDatabase.CreateTable(KTblName, *colset);
+	TUint32 createTblFc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###RDbDatabase::CreateTable(), Time=%d us\r\n"), createTblFc);
+	
+	//RDbDatabase::AlterTable()
+	_LIT(KColName4, "Col4");
+	TDbCol col4(KColName4, EDbColReal64);
+	colset->AddL(col4);
+	fc = User::FastCounter();
+	err = TheDatabase.AlterTable(KTblName, *colset);
+	TUint32 alterTblFc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###RDbDatabase::AlterTable(), Time=%d us\r\n"), alterTblFc);
+
+	//CDbKey
+	fc = User::FastCounter();
+	CDbKey* dbKey = CDbKey::NewLC();
+	TDbKeyCol keyCol1(KColName1, TDbKeyCol::EAsc);
+	dbKey->AddL(keyCol1);
+	TDbKeyCol keyCol2(KColName4, TDbKeyCol::EDesc);
+	dbKey->AddL(keyCol2);
+	TUint32 dbKeyFc = CalcTickDiff(fc, User::FastCounter());
+	PrintFcDiffAsUs(_L("###CDbKey::NewLC() & CDbKey::AddL(), Time=%d us\r\n"), dbKeyFc);
+	
+	//RDbDatabase::CreateIndex()
+	_LIT(KKeyName, "AKey");
+	fc = User::FastCounter();
+	err = TheDatabase.CreateIndex(KKeyName, KTblName, *dbKey);
+	TUint32 createIndexFc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###RDbDatabase::CreateIndex(), Time=%d us\r\n"), createIndexFc);
+	
+	CleanupStack::PopAndDestroy(dbKey);
+	CleanupStack::PopAndDestroy(colset);
+	
+	//RDbDatabase::TableNamesL()
+	fc = User::FastCounter();
+	CDbTableNames* tblNames = TheDatabase.TableNamesL();
+	TUint32 tblNamesFc = CalcTickDiff(fc, User::FastCounter());
+	delete tblNames;
+	PrintFcDiffAsUs(_L("###RDbDatabase::TableNamesL(), Time=%d us\r\n"), tblNamesFc);
+	
+	//RDbDatabase::IndexNamesL()
+	fc = User::FastCounter();
+	CDbIndexNames* idxNames = TheDatabase.IndexNamesL(KTblName);
+	TUint32 idxNamesFc = CalcTickDiff(fc, User::FastCounter());
+	delete idxNames;
+	PrintFcDiffAsUs(_L("###RDbDatabase::IndexNamesL(), Time=%d us\r\n"), idxNamesFc);
+
+	//RDbDatabase::ColSetL()
+	fc = User::FastCounter();
+	colset = TheDatabase.ColSetL(KTblName);
+	colSetFc = CalcTickDiff(fc, User::FastCounter());
+	delete colset;
+	PrintFcDiffAsUs(_L("###RDbDatabase::ColSetL(), Time=%d us\r\n"), colSetFc);
+	
+	//RDbDatabase::KeyL()
+	fc = User::FastCounter();
+	dbKey =  TheDatabase.KeyL(KKeyName, KTblName);
+	dbKeyFc = CalcTickDiff(fc, User::FastCounter());
+	delete dbKey;
+	PrintFcDiffAsUs(_L("###RDbDatabase::KeyL(), Time=%d us\r\n"), dbKeyFc);
+
+	//RDbDatabase::DropIndex()
+	fc = User::FastCounter();
+	err = TheDatabase.DropIndex(KKeyName, KTblName);
+	TUint32 dropIdxFc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###RDbDatabase::DropIndex(), Time=%d us\r\n"), dropIdxFc);
+	
+	//RDbDatabase::DropTable()
+	fc = User::FastCounter();
+	err = TheDatabase.DropTable(KTblName);
+	TUint32 dropTblFc = CalcTickDiff(fc, User::FastCounter());
+	TEST2(err, KErrNone);
+	PrintFcDiffAsUs(_L("###RDbDatabase::DropTable(), Time=%d us\r\n"), dropTblFc);
+	
+	TheDatabase.Close();
+	}
+
+void PrintDiskUsage(const TDesC& aPath, TInt aOffset = 0)
+	{
+	_LIT(KSpace, " ");
+	TheTest.Printf(_L("%*.*S%S\r\n"), aOffset, aOffset, &KSpace, &aPath);
+	TFindFile findFile(TheFs);
+	CDir* fileNameCol = NULL;
+	TBuf<8> fileNameMask;
+	fileNameMask.Copy(_L("*.*"));
+	TInt err = findFile.FindWildByDir(fileNameMask, aPath, fileNameCol);
+	if(err == KErrNone)
+		{
+		do
+			{
+			const TDesC& file = findFile.File();//"file" variable contains the drive and the path. the file name in "file" is invalid in this case.
+			(void)TheParse.Set(file, NULL, NULL);
+			TPtrC driveName = TheParse.Drive();
+			if(aPath.FindF(driveName) < 0)
+				{
+				goto cont;
+				}
+			
+			TInt cnt = fileNameCol->Count();
+			for(TInt i=0;i<cnt;++i)
+				{
+				const ::TEntry& entry = (*fileNameCol)[i];
+				if(!entry.IsDir())
+					{
+					TheTest.Printf(_L("%*.*S    %S, size=%d\r\n"), aOffset, aOffset, &KSpace, &entry.iName, entry.iSize);
+					}
+				else
+					{
+					TBuf<100> path;
+					path.Copy(aPath);
+					path.Append(entry.iName);
+					path.Append(_L("\\"));
+					PrintDiskUsage(path, aOffset + 4);
+					}
+				}
+cont:			
+			delete fileNameCol;
+			fileNameCol = NULL;
+			} while((err = findFile.FindWild(fileNameCol)) == KErrNone);//Get the next set of files
+		}
+	else
+		{
+		TheTest.Printf(_L("  FindWildByDir() failed with err=%d\r\n"), err);
+		}
+	}
+
+void DoTestL()
+	{
+	GetFastCounterFrequency();
+
+	FileBlockSizeTestsL();
+
+	RecordLenTestL();
+
+	InsertTestsL();
+
+	UpdateTestsL();
+
+	DbInsertTestsL();
+
+	DbUpdateTestsL();
+
+	DbColWriteStreamTestsL();
+
+	DbColReadStreamTestsL();
+
+	DbUpdateTestL();
+
+	DbStoreDatabaseTestL();
+
+	DbDatabaseTestL();
+	}
+
+//Usage: "t_dbperf2 [<drive letter>:]"
+TInt E32Main()
+    {
+	TheTest.Title();
+	
+	TheTrapCleanup = CTrapCleanup::New();
+	TEST(TheTrapCleanup != NULL);
+	
+	//Construct test database file name
+	_LIT(KTestDatabase, "c:\\dbms-tst\\t_dbperf2.db");
+	TFileName fname;
+	User::CommandLine(fname);
+	TParse parse;
+	parse.Set(fname, &KTestDatabase, 0);
+	const TDesC& dbFilePath = parse.FullName();
+	TheDatabaseFileName.Copy(dbFilePath);
+	TheTest.Printf(_L("Test database: %S\r\n"), &TheDatabaseFileName);
+	//Construct test file name
+	_LIT(KTestFile, "c:\\dbms-tst\\t_dbperf2.dat");
+	parse.Set(fname, &KTestFile, 0);
+	const TDesC& testFilePath = parse.FullName();
+	TheTestFileName.Copy(testFilePath);
+
+	__UHEAP_MARK;
+
+	TInt err = TheFs.Connect();
+	TEST2(err, KErrNone);
+	err = TheFs.MkDir(TheDatabaseFileName);
+	TheTest.Printf(_L("MkDir(): err=%d\r\n"), err);
+	TEST(err == KErrNone || err == KErrAlreadyExists);
+
+	DeleteFile(TheDatabaseFileName);
+	TRAP(err, DoTestL());
+	DeleteFile(TheDatabaseFileName);
+	DeleteFile(TheTestFileName);
+	TEST2(err, KErrNone);
+
+	TheTest.Printf(_L("====================================================\r\n"));
+	PrintDiskUsage(_L("c:\\"));
+	TheTest.Printf(_L("====================================================\r\n"));
+	
+	CloseAll();
+
+	__UHEAP_MARKEND;
+
+	TheTest.End();
+	TheTest.Close();
+	
+	delete TheTrapCleanup;
+	return KErrNone;
+    }