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

	WriteLine(line);

	}

//

// returns the integer n from the ' = n ' which must follow in the statement

//

TInt TScript::IntValue()

	{

	TScriptToken keyword;

	GetNextTokenFromStatement(keyword);

	if (keyword.Compare(_L("="))!=0)

		WriteError(_L("expected '=' missing"));

	iStatement.SkipSpaceAndMark();

	TInt num=0;

	TInt err=iStatement.Val(num);

	if (err!=KErrNone)

		WriteError(_L("expected number missing"));

	return num;

	}

TKeyword TScript::Keyword(const TDesC& aKeyword) const

	{

	for (TInt ii=0; ii<ENumKeywords; ++ii)

		{

		if (aKeyword.FindF(KScriptKeywords[ii])==0)

			return TKeyword(ii);

		}

	return EUnknown;

	}

//

// gets the next token from iStatement

//

void TScript::GetNextTokenFromStatement(TDes& aToken)

	{

	iStatement.SkipSpaceAndMark();

	TUint c;

	do

		{

		c=iStatement.Get();

		if (c=='=' || c=='!')

			break;

		} while (iStatement.Peek().IsAlphaDigit());

	aToken=iStatement.MarkedToken();

	iStatement.SkipSpaceAndMark();

	}

//

// gets the next token from iLine

//

void TScript::GetNextTokenFromLine(TDes& aToken)

	{

	iLine.SkipSpaceAndMark();

	TUint c=0;

	TChar cc=c;

	TBool literal=EFalse;

	do

		{

		c=iLine.Get();

		if (!c)

			{

			AppendNextLine();

			iLine.SkipSpaceAndMark();

			c=iLine.Get();

			}

		if (c=='\'' || c=='#')

			literal=!literal;

		if ((c==',' || c=='(' || c==')' || c=='{' || c=='}' || c=='!' ) && !literal)

			break;

		cc=iLine.Peek();

		} while (cc.IsAlphaDigit() || literal || TUint(cc)=='.' || TUint(cc)=='+' || TUint(cc)=='-');

	aToken=iLine.MarkedToken();

	if (TUint(cc)==';')					// ignore semi-colons - they're optional

		iLine.Get();

	iLine.SkipSpaceAndMark();

	if (c=='!')

		{

		iStatement=iLine.Remainder();

		TPtrC comment=iStatement.Remainder();

		WriteComment(comment);

		iLine=TPtrC();

		GetNextTokenFromLine(aToken);

		}

	}

//

// class TScriptEngine

//

TScriptEngine::TScriptEngine()

	: iTextComparison(EDbCompareNormal),iTimer(iScript),iEcho(EFalse),iWindow(EFalse),iAccess(RDbRowSet::EReadOnly)

	{}

//

// runs the script file

//

void TScriptEngine::RunL()

	{

	while (iScript.ReadNextStatement()!=KErrEof)

		ExecuteL();

	TestForNoError();

	}

void TScriptEngine::TestForNoError()

	{

	if (iResults.iError!=KErrNone)

		{

		TScriptLine line;

		line.Format(_L("unexpected error %d"),iResults.iError);

		FatalSqlError(line);

		}

	}

void TScriptEngine::ExecuteL()

	{

	if (ExecuteScriptL()!=KErrNone && ExecuteSql()!=KErrNone)

		FatalSqlError(_L("syntax error"));

	}

TInt TScriptEngine::ExecuteScriptL()

	{

	TKeyword keyword=iScript.Keyword(iScript.Statement());

	if (keyword!=EError)

		TestForNoError();

	switch (keyword)

		{

	case EPrint:

		DoPrintL();

		break;

	case ERows:

		DoRows();

		break;

	case ELoad:

		DoLoadDb();

		break;

	case EEcho:

		DoEcho();

		break;

	case EWindow:

		DoWindow();

		break;

	case EAccess:

		DoAccess();

		break;

	case ECompare:

		DoCompareL();

		break;

	case EError:

		DoError();

		break;

	case EPopulate:

		DoPopulate();

		break;

	case EComment:

		DoComment();

		break;

	case EResults:

		DoResultsL();

		break;

	case EBuild:

		DoBuildTable();

		break;

	case EQuery:

		DoQuery();

		break;

	case ENormal:

	case EFolded:

	case ECollated:

		DoTextComparison(keyword);

		break;

	case EStart:

		DoStartTimer();

		break;

	case EStop:

		DoStopTimer();

		break;

	case EUnknown:

	default:

		return KErrNotFound;

		}

	return KErrNone;

	}

TInt TScriptEngine::ExecuteSql()

	{

	return ExecuteSql(iScript.Statement());

	}

TInt TScriptEngine::ExecuteSql(const TDesC& aSql)

	{

	if (iEcho)

		{

		TScriptLine line(_L("\nSQL:\t"));

		line.Append(aSql);

		iScript.WriteLine(line);

		}

	iResults.iLineNo=iScript.LineNo();

	iResults.iLine=aSql;

	TSqlStatement statement(aSql,iResults);

	return statement.Execute(iTextComparison,iAccess,iWindow);

	}

void TScriptEngine::DoStartTimer()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("START")), 0);

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("TIMER")), 0);

	//

	iTimer.Start(_L("Timer started"));

	}

void TScriptEngine::DoStopTimer()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("STOP")), 0);

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("TIMER")), 0);

	//

	iTimer.Stop(_L("Timer stopped"));

	}

void TScriptEngine::DoTextComparison(TKeyword aKeyword)

	{

	TPtrC line;

	switch (aKeyword)

		{

	case ENormal:

		iTextComparison=EDbCompareNormal;

		line.Set(_L("[Normal text comparison]"));

		break;

	case EFolded:

		iTextComparison=EDbCompareFolded;

		line.Set(_L("[Folded text comparison]"));

		break;

	case ECollated:

		iTextComparison=EDbCompareCollated;

		line.Set(_L("[Collated text comparison]"));

		break;

	default:

		TEST(0);

		}

	iScript.WriteLine(line);

	}

void TScriptEngine::DoComment()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("!")), 0);

	//

	TPtrC comment=iScript.Statement();

	iScript.WriteComment(comment);

	iScript.ConsumeLine();

	}

void TScriptEngine::DoError()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("ERROR")), 0);

	//

	TScriptLine line;

	if (iScript.Statement().Length()==0)

		{

		if (iResults.iError>=0)

			FatalSqlError(_L("no error when one was expected"));

		line=_L("\t\tERROR OK");

		}

	else

		{

		TInt err=iScript.IntValue();

		if (iResults.iError!=err)

			{

			line.Format(_L("expected error %d, actual error %d"),err,iResults.iError);

			FatalSqlError(line);

			}

		line.Format(_L("\t\tERROR=%D OK"),err);

		}

	iResults.iError=0;

	iScript.WriteLine(line);

	}

void TScriptEngine::DoRows()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("ROWS")), 0);

	//

	TScriptLine line;

	TInt rows=iScript.IntValue();

	if (iResults.iRows!=rows)

		{

		line.Format(_L("expected rows %d, actual rows %d"),rows,iResults.iRows);

		FatalSqlError(line);

		}

	line.Format(_L("\t\tROWS=%D OK"),rows);

	iScript.WriteLine(line);

	}

void TScriptEngine::DoLoadDb()

	{

	// test its right function

	TScriptToken token;

	iScript.GetNextTokenFromStatement(token);

	TEST2(token.CompareF(_L("LOAD")), 0);

	//

	TFileName database(iScript.Statement());

	TheDatabase.Close();

	TScriptLine line;

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

	iScript.WriteLine(line);

	TEST2(TheDatabase.Open(TheFs,database), KErrNone);

	}

void TScriptEngine::DoEcho()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("ECHO")), 0);

	//

	iScript.GetNextTokenFromStatement(keyword);

	if (keyword.CompareF(_L("OFF"))==0)

		{

		iEcho=EFalse;

		iScript.WriteLine(_L("Echo is off"));

		}

	else if (keyword.CompareF(_L("ON"))==0)

		{

		iEcho=ETrue;

		iScript.WriteLine(_L("Echo is on"));

		}

	else

		FatalError(_L("Expected ON|OFF to follow ECHO statement"));

	}

void TScriptEngine::DoWindow()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("WINDOW")), 0);

	//

	iScript.GetNextTokenFromStatement(keyword);

	if (keyword.CompareF(_L("OFF"))==0)

		{

		iWindow=EFalse;

		iScript.WriteLine(_L("Window is off"));

		}

	else if (keyword.CompareF(_L("ON"))==0)

		{

		iWindow=ETrue;

		iScript.WriteLine(_L("Window is on"));

		}

	else

		FatalError(_L("Expected ON|OFF to follow WINDOW statement"));

	}

void TScriptEngine::DoAccess()

	{

	// test its right function

	TScriptToken keyword;

	iScript.GetNextTokenFromStatement(keyword);

	TEST2(keyword.CompareF(_L("ACCESS")), 0);

	//

	iScript.GetNextTokenFromStatement(keyword);

	if (keyword.CompareF(_L("UPDATE"))==0)

		{

		iAccess=RDbRowSet::EUpdatable;

		iScript.WriteLine(_L("Access is updateable"));

		}

	else if (keyword.CompareF(_L("READ"))==0)

		{

		iAccess=RDbRowSet::EReadOnly;

		iScript.WriteLine(_L("Access is read only"));

		}

	else if (keyword.CompareF(_L("INSERT"))==0)

		{

		iAccess=RDbRowSet::EInsertOnly;

		iScript.WriteLine(_L("Access is insert only"));

		}

	else

		FatalError(_L("Expected UPDATE|INSERT|READ to follow ACCESS statement"));

	}

void TScriptEngine::DoResultsL()

	{

	// test its right function

	TScriptToken token;

	iScript.GetNextTokenFromLine(token);

	TEST2(token.CompareF(_L("RESULTS")), 0);

	//

	iScript.GetNextTokenFromLine(token);

	if (token.Compare(_L("{"))!=0)

		FatalError(_L("missing '{'"));

	iScript.GetNextTokenFromLine(token);					// first value

	TLex value;

	RDbRowSet& rowset=iResults.iView;

	CDbColSet* colset=rowset.ColSetL();

	CleanupStack::PushL(colset);

	TDbColNo colno=colset->ColNo(KRowIdColName);

	CArrayFixFlat<TInt>* rowIdScript=new CArrayFixFlat<TInt>(4);

	CleanupStack::PushL(rowIdScript);

	CArrayFixFlat<TInt>* rowIdView=new CArrayFixFlat<TInt>(4);

	CleanupStack::PushL(rowIdView);

	rowset.BeginningL();

	while (rowset.NextL())

		{

		rowset.GetL();

		TUint rIdScript;

		value=token;

		if (value.Val(rIdScript)!=KErrNone)

			{

			TScriptLine line;

			line.Format(_L("Unable to extract row id from \"%S\""),&token);

			FatalError(line);

			}

		TUint rIdView=rowset.ColUint(colno);

		rowIdScript->AppendL(rIdScript);

		rowIdView->AppendL(rIdView);

		iScript.GetNextTokenFromLine(token);

		if (token.Compare(_L(","))==0 || token.Compare(_L("}"))==0)

			{

			if (rowIdScript->Count())

				{

				TKeyArrayFix key(0,ECmpTInt);

				rowIdScript->Sort(key);

				rowIdView->Sort(key);

				for (TInt ii=0;ii<rowIdScript->Count();++ii)

					{

					TInt expectedId=(*rowIdScript)[ii];

					TInt actualId=(*rowIdView)[ii];

					if (actualId!=expectedId)

						{

						TScriptLine line;

						line.Format(_L("expected row id %d, actual row id %d"),actualId,expectedId);

						FatalError(line);

						}

					}

				rowIdScript->Reset();

				rowIdView->Reset();

				}

			if (token.Compare(_L(","))==0)

				iScript.GetNextTokenFromLine(token);

			}

		}

	if (token.Compare(_L("}"))!=0)

		FatalError(_L("too many results expected"));

	CleanupStack::PopAndDestroy(3);	// arrays + colset

	iScript.ConsumeStatement();

	}

//

// same as Sql create statement, but adds a counter

//

void TScriptEngine::DoBuildTable()