// Copyright (c) 2008-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 <e32test.h>

#include <bautils.h>

#include <sqldb.h>

#include "t_sqlcmdlineutil.h"

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

RTest			TheTest(_L("t_sqlperformance2 test"));

RSqlDatabase 	TheDb;

TFileName		TheDbFileName;

RFs				TheFs;

TBuf<200> 		TheTestTitle;

TCmdLineParams 	TheCmdLineParams;

TBuf8<200> 		TheSqlConfigString;

_LIT(KUtf8,  "UTF8 ");

_LIT(KUtf16, "UTF16");

TInt TheBlobSize = 1024 * 256;

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

void TestEnvDestroy()

	{

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	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);

    //

    TInt driveNumber = -1;

	err = RFs::CharToDrive(TheCmdLineParams.iDriveName[0], driveNumber);

	TEST2(err, KErrNone);

	TDriveNumber driveNo = static_cast <TDriveNumber> (driveNumber);

	TDriveInfo driveInfo;

	err = TheFs.Drive(driveInfo, driveNo);

	TEST2(err, KErrNone);

    //Create the test directory

	err = TheFs.MkDirAll(TheDbFileName);

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

    //Print drive info and the database name 

	_LIT(KType1, "Not present");

	_LIT(KType2, "Unknown");

	_LIT(KType3, "Floppy");

	_LIT(KType4, "Hard disk");

	_LIT(KType5, "CD ROM");

	_LIT(KType6, "RAM disk");

	_LIT(KType7, "Flash");

	_LIT(KType8, "ROM drive");

	_LIT(KType9, "Remote drive");

	_LIT(KType10,"NAND flash");

	_LIT(KType11,"Rotating media");

	TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};

	TheTest.Printf(_L("Drive %C: %S. File: \"%S\"\r\n"), 'A' + driveNo, &KMediaTypeNames[driveInfo.iType], &TheDbFileName);

	}

void PrintWriteTime(TTimeIntervalMicroSeconds aTime, TTimeIntervalMicroSeconds aWriteTime, TTimeIntervalMicroSeconds aCommitTime)

	{

	TheTest.Printf(_L("####Execution time: %d ms, Write: %d ms, Commit: %d ms\r\n"), 

		(TInt)(aTime.Int64() / 1000), (TInt)(aWriteTime.Int64() / 1000), (TInt)(aCommitTime.Int64() / 1000));

	}

void PrintReadTime(TTimeIntervalMicroSeconds aPrepareTime, TTimeIntervalMicroSeconds aNextTime, TTimeIntervalMicroSeconds aReadTime)

	{

	TInt executionTime = (TInt)(aPrepareTime.Int64() / 1000) + (TInt)(aNextTime.Int64() / 1000) + (TInt)(aReadTime.Int64() / 1000);

	TheTest.Printf(_L("####Execution time: %d ms, Prepare: %d ms, Next: %d ms, Read: %d ms\r\n"), 

		executionTime, (TInt)(aPrepareTime.Int64() / 1000), (TInt)(aNextTime.Int64() / 1000), (TInt)(aReadTime.Int64() / 1000));

	}

void PrintReadTime(TTimeIntervalMicroSeconds aOpenTime, TTimeIntervalMicroSeconds aReadTime)

	{

	TInt executionTime = (TInt)(aOpenTime.Int64() / 1000) + (TInt)(aReadTime.Int64() / 1000);

	TheTest.Printf(_L("####Execution time: %d ms, Open: %d ms, Read: %d ms\r\n"), 

		executionTime, (TInt)(aOpenTime.Int64() / 1000), (TInt)(aReadTime.Int64() / 1000));

	}

void PrintFileSize(RSqlDatabase& aDb)

	{

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

	}

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

void CreateTestDb()

	{

	(void)RSqlDatabase::Delete(TheDbFileName);

	TInt err = TheDb.Create(TheDbFileName, &TheSqlConfigString);

	TEST2(err, KErrNone);

	err = TheDb.Exec(_L8("CREATE TABLE A(B BLOB)"));

	TEST2(err, 1);

	}

void DoWriteBlobIncrL(const TDesC8& aData, 

					  TTime& aT1, 

					  TTime& aT2,

					  TTime& aT3,

					  TTime& aT4)

	{

	RSqlBlobWriteStream strm;

	CleanupClosePushL(strm);

	aT1.HomeTime();

	strm.OpenL(TheDb, _L("A"), _L("B"));	

	strm.WriteL(aData);

	aT2.HomeTime();

	aT3.HomeTime();

	strm.CommitL();

	aT4.HomeTime();

	CleanupStack::PopAndDestroy(&strm);

	}

void InsertZeroBlob(TBool aDoPrintTime = EFalse)

	{

	TBuf<100> sql;

	sql.Format(_L("INSERT INTO A VALUES(zeroblob(%d))"), TheBlobSize);

	TTime t1, t2;

	t1.HomeTime();

	TInt err = TheDb.Exec(sql);

	t2.HomeTime();

	TEST2(err, 1);

	TTimeIntervalMicroSeconds insertTime = t2.MicroSecondsFrom(t1);

	if(aDoPrintTime)

		{

		PrintWriteTime(insertTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

		}

	}

void InsertRealBlob()

	{

	HBufC8* data = HBufC8::New(TheBlobSize);

	TEST(data != NULL);

	TPtr8 dataptr = data->Des();

	dataptr.SetLength(TheBlobSize);

	dataptr.Fill(TChar('A'));

	RSqlStatement stmt;

	TInt err = stmt.Prepare(TheDb, _L8("INSERT INTO A VALUES(:Prm)"));

	TEST2(err, KErrNone);

	RSqlParamWriteStream strm;

	err = strm.BindBinary(stmt, 0);

	TEST2(err, KErrNone);

	TRAP(err, strm.WriteL(dataptr));

	TEST2(err, KErrNone);

	TRAP(err, strm.CommitL());

	TEST2(err, KErrNone);

	strm.Close();

	err = stmt.Exec();	

	TEST2(err, 1);			

	stmt.Close();	

	delete data;

	}

void InsertBlobIncr()

	{

	HBufC8* data = HBufC8::New(TheBlobSize);

	TEST(data != NULL);

	TPtr8 dataptr = data->Des();

	dataptr.SetLength(TheBlobSize);

	dataptr.Fill(TChar('B'));

	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

	TBuf<100> sql;

	sql.Format(_L("INSERT INTO A VALUES(zeroblob(%d))"), TheBlobSize);

	TTime t1, t2, subt1, subt2, subt3, subt4;

	t1.HomeTime();

	TInt err = TheDb.Exec(_L8("BEGIN"));

	TEST(err >= 0);

	err = TheDb.Exec(sql);

	TEST2(err, 1);

	TRAP(err, DoWriteBlobIncrL(dataptr, subt1, subt2, subt3, subt4));

	TEST2(err, KErrNone);

	err = TheDb.Exec(_L8("COMMIT"));

	TEST(err >= 0);

	t2.HomeTime();

	totalTime = t2.MicroSecondsFrom(t1);

	writeTime = subt2.MicroSecondsFrom(subt1);

	commitTime = subt4.MicroSecondsFrom(subt3);

	PrintWriteTime(totalTime, writeTime, commitTime);

	delete data;

	}

void InsertBlobExec()

	{

	HBufC8* buf = HBufC8::New(TheBlobSize * 2 + 100);

	TEST(buf != NULL);

	TPtr8 sql = buf->Des();

	_LIT8(KStr, "INSERT INTO A VALUES(x'");

	sql.SetLength(TheBlobSize * 2 + KStr().Length());

	sql.Fill(TChar('A'));

	sql.Replace(0, KStr().Length(), KStr);

	sql.Append(_L8("')"));

	TTime t1, t2;

	t1.HomeTime();		

	TInt err = TheDb.Exec(sql);

	t2.HomeTime();

	TEST2(err, 1);

	TTimeIntervalMicroSeconds totalTime = t2.MicroSecondsFrom(t1);

	PrintWriteTime(totalTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

	delete buf;	

	}

void InsertBlobBindStreamPrm()

	{

	HBufC8* data = HBufC8::New(TheBlobSize);

	TEST(data != NULL);

	TPtr8 dataptr = data->Des();

	dataptr.SetLength(TheBlobSize);

	dataptr.Fill(TChar('A'));

	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

	TTime t1, t2, t3, t4, t5, t6;

	t1.HomeTime();

	RSqlStatement stmt;

	TInt err = stmt.Prepare(TheDb, _L8("INSERT INTO A VALUES(:Prm)"));

	TEST2(err, KErrNone);

	RSqlParamWriteStream strm;

	err = strm.BindBinary(stmt, 0);

	TEST2(err, KErrNone);

	t3.HomeTime();

	TRAP(err, strm.WriteL(dataptr));

	t4.HomeTime();

	TEST2(err, KErrNone);

	t5.HomeTime();

	TRAP(err, strm.CommitL());

	t6.HomeTime();

	TEST2(err, KErrNone);

	err = stmt.Exec();	

	strm.Close();

	stmt.Close();	

	t2.HomeTime();

	TEST2(err, 1);

	totalTime = t2.MicroSecondsFrom(t1);

	writeTime = t4.MicroSecondsFrom(t3);

	commitTime = t6.MicroSecondsFrom(t5);

	PrintWriteTime(totalTime, writeTime, commitTime);

	delete data;	

	}

void UpdateBlobIncr()

	{

	HBufC8* data = HBufC8::New(TheBlobSize);

	TEST(data != NULL);

	TPtr8 dataptr = data->Des();

	dataptr.SetLength(TheBlobSize);

	dataptr.Fill(TChar('A'));

	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

	TTime t1, t2, subt1, subt2, subt3, subt4;

	t1.HomeTime();

	TInt err = TheDb.Exec(_L8("BEGIN"));

	TEST(err >= 0);

	TRAP(err, DoWriteBlobIncrL(dataptr, subt1, subt2, subt3, subt4));

	TEST2(err, KErrNone);

	err = TheDb.Exec(_L8("COMMIT"));

	TEST(err >= 0);

	t2.HomeTime();

	totalTime = t2.MicroSecondsFrom(t1);

	writeTime = subt2.MicroSecondsFrom(subt1);

	commitTime = subt4.MicroSecondsFrom(subt3);

	PrintWriteTime(totalTime, writeTime, commitTime);

	delete data;

	}

void UpdateBlobExec()

	{

	HBufC8* buf = HBufC8::New(TheBlobSize * 2 + 100);

	TEST(buf != NULL);

	TPtr8 sql = buf->Des();

	_LIT8(KStr, "UPDATE A SET B=x'");

	sql.SetLength(TheBlobSize * 2 + KStr().Length());

	sql.Fill(TChar('B'));

	sql.Replace(0, KStr().Length(), KStr);

	sql.Append(_L8("'"));

	TTime t1, t2;

	t1.HomeTime();			

	TInt err = TheDb.Exec(sql);	

	t2.HomeTime();

	TEST2(err, 1);

	TTimeIntervalMicroSeconds totalTime = t2.MicroSecondsFrom(t1);

	PrintWriteTime(totalTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

	delete buf;	

	}

void UpdateBlobBindStreamPrm()

	{

	HBufC8* data = HBufC8::New(TheBlobSize);

	TEST(data != NULL);

	TPtr8 dataptr = data->Des();

	dataptr.SetLength(TheBlobSize);

	dataptr.Fill(TChar('B'));

	TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;

	TTime t1, t2, t3, t4, t5, t6;

	t1.HomeTime();

	RSqlStatement stmt;

	TInt err = stmt.Prepare(TheDb, _L8("UPDATE A SET B=(:Prm)"));

	TEST2(err, KErrNone);

	RSqlParamWriteStream strm;

	err = strm.BindBinary(stmt, 0);

	TEST2(err, KErrNone);

	t3.HomeTime();;

	TRAP(err, strm.WriteL(dataptr));

	t4.HomeTime();

	TEST2(err, KErrNone);

	t5.HomeTime();

	TRAP(err, strm.CommitL());

	t6.HomeTime();

	TEST2(err, KErrNone);

	err = stmt.Exec();	

	strm.Close();		

	stmt.Close();	

	t2.HomeTime();

	TEST2(err, 1);

	totalTime = t2.MicroSecondsFrom(t1);

	writeTime = t4.MicroSecondsFrom(t3);

	commitTime = t6.MicroSecondsFrom(t5);

	PrintWriteTime(totalTime, writeTime, commitTime);

	delete data;	

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4084

@SYMTestCaseDesc		SQL, BLOB write, performance tests.

						Tests insertion and updates of BLOBs using the old

						APIs and the new RSqlBlobWriteStream APIs.

@SYMTestPriority		Medium

@SYMTestActions			Insertion and updates of blobs using the old and new APIs.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ5912

*/

void BlobWriteTest()

	{	

	TheTest.Printf(_L("Blob size=%d Kb\r\n"), TheBlobSize / 1024);

	//Insert a blob

	TheTest.Printf(_L("==================================================================\r\n"));

	CreateTestDb();

	TheTest.Printf(_L("INSERT zeroblob - RSqlDatabase::Exec()\r\n"));

	PrintFileSize(TheDb);

	InsertZeroBlob(ETrue);

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("INSERT blob - RSqlParamWriteStream\r\n"));

	PrintFileSize(TheDb);

	InsertBlobBindStreamPrm();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("INSERT blob - RSqlDatabase::Exec()\r\n"));

	PrintFileSize(TheDb);

	InsertBlobExec();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("INSERT blob - RSqlBlobWriteStream + transaction\r\n"));

	PrintFileSize(TheDb);

	InsertBlobIncr();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	// Update a blob 

	TheTest.Printf(_L("==================================================================\r\n"));

	CreateTestDb();

	TheTest.Printf(_L("UPDATE zeroblob - RSqlParamWriteStream\r\n"));

	PrintFileSize(TheDb);

	InsertZeroBlob();

	UpdateBlobBindStreamPrm();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("UPDATE blob - RSqlParamWriteStream\r\n"));

	PrintFileSize(TheDb);

	InsertRealBlob();

	UpdateBlobBindStreamPrm();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("UPDATE zeroblob - RSqlDatabase::Exec()\r\n"));

	PrintFileSize(TheDb);

	InsertZeroBlob();

	UpdateBlobExec();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("UPDATE blob - RSqlDatabase::Exec()\r\n"));

	PrintFileSize(TheDb);

	InsertRealBlob();

	UpdateBlobExec();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("UPDATE zeroblob - RSqlBlobWriteStream + transaction\r\n"));

	PrintFileSize(TheDb);

	InsertZeroBlob();

	UpdateBlobIncr();

	PrintFileSize(TheDb);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheDbFileName);

	CreateTestDb();

	TheTest.Printf(_L("UPDATE blob - RSqlBlobWriteStream + transaction\r\n"));

	PrintFileSize(TheDb);