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