// Copyright (c) 1998-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 <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include <d32dbmsconstants.h>

LOCAL_D RTest TheTest(_L("t_dbscript"));

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RDbNamedDatabase TheDatabase;

LOCAL_D RFs TheFs;

LOCAL_D RDbView TheView;

//

const TPtrC KTestDatabase=_L("c:\\dbms-tst\\t_script.db");

const TPtrC KRomScriptFile=_L("z:\\test\\t_script.txt");

const TPtrC KOutputFile=_L("c:\\dbms-tst\\t_script.log");

const TInt KTestCleanupStack=0x20;

const TPtrC KDDLKeywords[]={_L("CREATE"),_L("DROP"),_L("ALTER")};

const TPtrC KDMLKeywords[]={_L("INSERT"),_L("DELETE"),_L("UPDATE")};

const TPtrC KQueryKeywords[]={_L("SELECT")};

const TPtrC KScriptKeywords[]={_L("PRINT"),_L("ROWS"),_L("COMPARE"),_L("ERROR"),_L("!"),

							   _L("POPULATE"),_L("RESULTS"),_L("BUILD"),_L("QUERY"),

							   _L("NORMAL"),_L("FOLDED"),_L("COLLATED"),_L("START"),_L("STOP"),

							   _L("LOAD"),_L("ECHO"),_L("WINDOW"),_L("ACCESS")};

const TPtrC KRowIdColName=_L("Rw");

enum TKeyword {EPrint,ERows,ECompare,EError,EComment,EPopulate,EResults,EBuild,EQuery,ENormal,

               EFolded,ECollated,EStart,EStop,ELoad,EEcho,EWindow,EAccess,ENumKeywords,EUnknown};

//

typedef TBuf<256> TScriptLine;

typedef TBuf<256> TScriptToken;

//

#define ARRAY_SIZE(array) (sizeof(array)/sizeof(array[0]))

class TScript;

class TTimer

	{

public:

	inline TTimer(TScript& aScript);

	void Start(const TDesC& aDes);

	void Stop(const TDesC& aDes);

private:

	TUint iTicks;

	TScript& iScript;

	};

class TResults

	{

public:

	inline TResults();

public:

	RDbView& iView;

	TInt iError;

	TInt iRows;

	TInt iLineNo;

	TScriptLine iLine;

	};

class TSqlStatement

	{

private:

	enum TSqlType {EDML,EDDL,EQuery,EUnknown};

public:

	inline TSqlStatement(const TDesC& aSql,TResults& aResults);

	TInt Execute(TDbTextComparison aTextComparison=EDbCompareNormal,

		RDbRowSet::TAccess aAccess=RDbRowSet::EReadOnly,TBool aWindow=EFalse) const;

private:

	void ExecuteSql(TDbTextComparison aTextComparison) const;

	void ExecuteQuery(RDbRowSet::TAccess aAccess,TBool aWindow) const;

	TSqlType SqlType() const;

private:

	const TDesC& iSql;

	TResults& iResults;

	};

class TScript

	{

public:

	TScript();

	~TScript()

		{

		iFile.Close();

		}

	TInt ReadNextStatement();

	void GetNextTokenFromStatement(TDes& aToken);

	void GetNextTokenFromLine(TDes& aToken);

	TPtrC Statement();

	TInt IntValue();

	void WriteLine(const TDesC& aLine);

	void WriteError(const TDesC& aLine);

	void WriteSqlError(const TResults& aResults,const TDesC& aLine);

	void WriteComment(const TDesC& aLine);

	TKeyword Keyword(const TDesC& aKeyword) const;

	void ConsumeLine();

	void ConsumeStatement();

	inline TInt LineNo() const;

private:

	TInt ReadNextLine();

	TInt AppendNextLine();

	TBool IsStatement();

private:

	TFileText iInput;

	TFileText iOutput;

	TScriptLine iBuf;

	TLex iStatement;

	TLex iLine;

	TInt iLineNo;

	RFile iFile;

	};

class TScriptEngine

	{

public:

	inline TScriptEngine();

	void RunL();

private:

	void ExecuteL();

	TInt ExecuteScriptL();

	TInt ExecuteSql(const TDesC& aSql);

	TInt ExecuteSql();

	// keyword operations

	void DoPrintL();

	void DoComment();

	void DoError();

	void DoEcho();

	void DoWindow();

	void DoAccess();

	void DoRows();

	void DoCompareL();

	void DoPopulate();

	void DoResultsL();

	void DoBuildTable();

	void DoQuery();

	void DoTextComparison(TKeyword aKeyword);

	void DoStartTimer();

	void DoStopTimer();

	void DoLoadDb();

	//

	void PrintL(RDbRowSet& aRowSet);

	void CompareL(RDbRowSet& aRowSet);

	void CompareValues(RDbRowSet& aRowSet,TDbColNo ColNo,TDbColType aType,const TDesC& aToken);

	void FatalError(const TDesC& aLine);

	void FatalError();

	void FatalSqlError(const TDesC& aLine);

	void TestForNoError();

private:

	TScript iScript;

	TResults iResults;

	TDbTextComparison iTextComparison;

	TTimer iTimer;

	TBool iEcho;

	TBool iWindow;

	RDbRowSet::TAccess iAccess;

	};

//

// class TTimer

//

inline TTimer::TTimer(TScript& aScript)

	: iScript(aScript)

	{}

void TTimer::Start(const TDesC& aDes)

	{

	TScriptLine line;

	line.Format(_L("%S: "),&aDes);

	iScript.WriteLine(line);

	iTicks=User::TickCount();

	}

void TTimer::Stop(const TDesC& aDes)

	{

	TScriptLine line;

	line.Format(_L("%S: "),&aDes);

#ifdef __EPOC32__

#define TICK_TIME 15625

#else

#define	TICK_TIME 100000

#endif

	TInt microSec=(User::TickCount()-iTicks)*TICK_TIME;

	TUint sec=microSec/1000000;

	TUint centi=(microSec/10000)-sec*100;

	line.AppendFormat(_L("%u.%02us\n"),sec,centi);

	iScript.WriteLine(line);

	}

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

LOCAL_C void DeleteDataFile(const TDesC& aFullName)

    {

    RFs fsSession;

    TInt err = fsSession.Connect();

    if(err == KErrNone)

        {

        TEntry entry;

        if(fsSession.Entry(aFullName, entry) == KErrNone)

            {

            RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

            err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

            if(err != KErrNone)

                {

                RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

                }

            err = fsSession.Delete(aFullName);

            if(err != KErrNone)

                {

                RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

                }

            }

        fsSession.Close();

        }

    else

        {

        RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

        }

    }

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

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

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

        {

        RDebug::Print(_L("*** Expression evaluated to false\r\n"));

        DeleteDataFile(KTestDatabase);

        DeleteDataFile(KOutputFile);

        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)

        {

        RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

        DeleteDataFile(KTestDatabase);

        DeleteDataFile(KOutputFile);

        TheTest(EFalse, aLine);

        }

    }

//Use these to test conditions.

#define TEST(arg) Check((arg), __LINE__)

#define TEST2(aValue, aExpected) Check(aValue, aExpected, __LINE__)

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

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

//

// class TResults

//

inline TResults::TResults()

	: iView(TheView),iError(KErrNone)

	{}

//

// class TSqlStatement

//

inline TSqlStatement::TSqlStatement(const TDesC& aSql,TResults& aResults)

	: iSql(aSql),iResults(aResults)

	{}

//

// executes DML or DDL

//

void TSqlStatement::ExecuteSql(TDbTextComparison aTextComparison) const

	{

	TInt r=TheDatabase.Execute(iSql,aTextComparison);

	if (r<0)

		iResults.iError=r;

	else

		{

		iResults.iError=KErrNone;

		iResults.iRows=r;

		}

	}

void TSqlStatement::ExecuteQuery(RDbRowSet::TAccess aAccess,TBool aWindow) const

	{

	iResults.iView.Close();			// discard any previous queries

	TInt& err=iResults.iError;

	if (aWindow)

		err=iResults.iView.Prepare(TheDatabase,iSql,KDbUnlimitedWindow,aAccess);

	else

		err=iResults.iView.Prepare(TheDatabase,iSql,aAccess);

	if (err==KErrNone)

		err=iResults.iView.EvaluateAll();

	}

//

// determines the type of sql statement by matching keywords

//

TSqlStatement::TSqlType TSqlStatement::SqlType() const

	{

	for (TUint i=0;i<ARRAY_SIZE(KDDLKeywords);++i)

		{

		if (iSql.FindF(KDDLKeywords[i])==0)

			return EDDL;

		}

	for (TUint ii=0;ii<ARRAY_SIZE(KDMLKeywords);++ii)

		{

		if (iSql.FindF(KDMLKeywords[ii])==0)

			return EDML;

		}

	for (TUint j=0;j<ARRAY_SIZE(KQueryKeywords);++j)

		{

		if (iSql.FindF(KQueryKeywords[j])==0)

			return EQuery;

		}

	return EUnknown;

	}

//

// executes the sql statement

//

TInt TSqlStatement::Execute(TDbTextComparison aTextComparison,RDbRowSet::TAccess aAccess,TBool aWindow) const

	{

	TInt r=KErrNone;

	switch (SqlType())

		{

	case EDDL:

	case EDML:

		ExecuteSql(aTextComparison);

		break;

	case EQuery:

		ExecuteQuery(aAccess,aWindow);

		break;

	case EUnknown:

	default:

		r=KErrNotFound;

		break;

		}

	return r;

	}

//

// class TScript

//

TScript::TScript()

	: iLineNo(0)

	{

	TheTest.Printf(_L("---TScript::TScript(), Open the script file \"%S\"\r\n"), &KRomScriptFile);

	RFile file;

	TInt r=file.Open(TheFs, KRomScriptFile, EFileRead);

	TEST2(r, KErrNone);

	iInput.Set(file);

    TheTest.Printf(_L("---TScript::TScript(), Create the file \"%S\"\r\n"), &KOutputFile);

	TEST2(file.Replace(TheFs, KOutputFile, EFileWrite), KErrNone);

	iOutput.Set(file);

	iFile = file;

	}

inline TInt TScript::LineNo() const

	{return iLineNo;}

//

//  checks for keywords which possibly conform to the usual statement format (ie end in ';')

//

TBool TScript::IsStatement()

	{

	if (iLine.Remainder().Length()==0)	// null statement

		return ETrue;

	TPtrC line=iLine.Remainder();

	TKeyword keyword=Keyword(line);

	switch (keyword)

		{

	case EPrint:

	case ERows:

	case EBuild:

	case EError:

	case EQuery:

	case ENormal:

	case EFolded:

	case ECollated:

	case EStart:

	case EStop:

	case ELoad:

	case EEcho:

	case EWindow:

	case EAccess:

	case EUnknown:						// could be sql

		return ETrue;

	case EComment:

	case EPopulate:

	case ECompare:

	case EResults:

		iStatement=line;				// not a statement, so make it the whole line

		return EFalse;

	default:

		TEST(0);

		return EFalse;

		}

	}

//

// reads the next non-blank statement or line

//

TInt TScript::ReadNextStatement()

	{

	TInt r=ReadNextLine();

	if (r!=KErrNone || !IsStatement())

		return r;

	TChar c=0;

	while (c!=';')

		{

		c=iLine.Get();

		if (!c)							// nothing left to read

			{

			r=AppendNextLine();

			if (r!=KErrNone)

				return r;

			}

		}

	iLine.UnGet();						// the semi-colon

	iStatement=iLine.MarkedToken();

	iLine.Get();						// the semi-colon

	iLine.SkipSpaceAndMark();

	return KErrNone;

	}

TPtrC TScript::Statement()

	{

	return iStatement.Remainder();

	}

void TScript::ConsumeLine()

	{

	iLine=TPtrC();

	iStatement=TPtrC();

	}

void TScript::ConsumeStatement()

	{

	iLine=iLine.Remainder();

	iStatement=TPtrC();

	}

//

// reads the next non-blank line into iLine

//

TInt TScript::ReadNextLine()

	{

	while (iLine.Remainder().Length()==0)

		{

		TInt r=iInput.Read(iBuf);

		if (r!=KErrNone)

			return r;

		if (iBuf.Length()>0 && iBuf[0]==0xfeff)	// unicode stream marker

			iBuf.Delete(0,1);

		iLineNo++;

		iLine=iBuf;

		iLine.SkipSpaceAndMark();

		}

	return KErrNone;

	}

//

// adds next line from file to iLine

//

TInt TScript::AppendNextLine()

	{

	TScriptLine line;

	do {

		TInt r=iInput.Read(line);

		if (r!=KErrNone)

			return r;

		iLineNo++;

		} while (line.Length()==0);

	iBuf=iLine.MarkedToken();

	iBuf.Append(line);

	iLine=iBuf;

	return KErrNone;

	}

void TScript::WriteError(const TDesC& aLine)

	{

	TScriptLine line;

	line.Format(_L("Error at line %d: %S\n"),iLineNo,&aLine);

	WriteLine(line);

	TheTest.Printf(line);

	}

void TScript::WriteSqlError(const TResults& aResults,const TDesC& aLine)

	{

	TScriptLine line;

	line.Format(_L("Error at line %d: %S :-\n"),aResults.iLineNo,&aLine);

	WriteLine(line);

	TheTest.Printf(line);

	line.Format(_L("\t%S\n"),&aResults.iLine);

	WriteLine(line);

	TheTest.Printf(line);

	}

void TScript::WriteLine(const TDesC& aLine)

	{

	TScriptLine l=aLine;

	l.Append('\r');

	iOutput.Write(l);

	}

void TScript::WriteComment(const TDesC& aLine)

	{

	TScriptLine line;

	line.Format(_L("\n%S"),&aLine);