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

// SQL parser

// 

//

#include "UQ_STD.H"

#include "D32Assert.h"

// class TSqlParser

const TInt KSqlError = -1;

TSqlParser::TSqlParser(const TDesC& aSql)

	: iSql(aSql)

	{

	NextToken();		// parse the first token

	}

TSqlTokenType TSqlParser::NextToken()

	{

	return iSql.NextToken(iToken);

	}

CSqlSearchCondition* TSqlParser::SqlError()

	{

	if (!Error())

		iToken.SetError(KErrArgument);

	return 0;

	}

TSqlTokenType TSqlParser::SqlErrorL()

//

// Report a SQL syntax error

//

	{

	return TSqlTokenType(__LEAVE_IF_ERROR(KErrArgument));

	}

TSqlTokenType TSqlParser::Parse(TSqlKeyword aKeyword)

//

// look for requested keyword, skip to the next token if found

// return the next token if found, else ESqlNoToken (==0)

//

	{

	return TSqlLexer::IsKeyword(aKeyword,iToken) ? NextToken() : ESqlNoToken;

	}

TSqlTokenType TSqlParser::ParseL(TSqlTokenType aToken)

//

// parse the desired token

//

	{

	return iToken!=aToken ? SqlErrorL() : NextToken();

	}

TSqlTokenType TSqlParser::ParseL(TSqlKeyword aKeyword)

//

// parse the desired keyword

//

	{

	TSqlTokenType t=Parse(aKeyword);

	return t==ESqlNoToken ? SqlErrorL() : t;

	}

TSqlKeyword TSqlParser::Keyword()

//

// parse a keyword

//

	{

	TSqlKeyword k=TSqlLexer::Keyword(iToken);

	if (k!=ESqlNotKeyword)

		NextToken();

	return k;

	}

TSqlTokenType TSqlParser::RightBracketL()

//

// parse a right bracket, and fail if not found

//

	{

	return ParseL(ESqlRightBracket);

	}

void TSqlParser::EndL()

//

// Check that the SQL has been fully parsed

//

	{

	if (iToken!=ESqlEos)

		SqlErrorL();

	}

TSqlTokenType TSqlParser::IdentifierL(TPtrC& aIdentifier)

//

// parse an identifer, fail if not found

//

	{

	if (iToken!=ESqlIdentifier)

		return SqlErrorL();

	const TText* p=iToken.Literal().Ptr();

	TInt len=iToken.Literal().End()-p;

	aIdentifier.Set(p,len);

	return NextToken();

	}

TPtrC TSqlParser::IdentifierL()

//

// parse an identifer, fail if not found

//

	{

	if (iToken!=ESqlIdentifier)

		SqlErrorL();

	return iToken.Literal().DesC();

	}

TSqlTokenType TSqlParser::ColumnNameL(RSqlColumnList& aList)

//

// Parse a column-identifier

//

	{

	__LEAVE_IF_ERROR(aList.Append(IdentifierL()));

	return NextToken();

	}

TSqlTokenType TSqlParser::ColumnListL(RSqlColumnList& aList)

//

// Parse a column-identifier-comma-list

//

	{

	for (;;)

		{

		TSqlTokenType t=ColumnNameL(aList);

		if (t!=ESqlComma)

			return t;

		NextToken();

		}

	}

TSqlTokenType TSqlParser::AddColumnSpecL(TDbCol& aDef)

//

// Parse an add-column-spec

//

	{

	aDef.iAttributes=0;

	aDef.iName=IdentifierL();

	NextToken();

//

	TDbColType type;

	switch (Keyword())

		{

	case ESqlKeyword_bit:

		type=EDbColBit;

		break;

	case ESqlKeyword_tinyint:

		type=EDbColInt8;

		break;

	case ESqlKeyword_smallint:

		type=EDbColInt16;

		break;

	case ESqlKeyword_integer:

		type=EDbColInt32;

		break;

	case ESqlKeyword_counter:

		aDef.iAttributes=aDef.EAutoIncrement;

		type=EDbColUint32;

		break;

	case ESqlKeyword_bigint:

		type=EDbColInt64;

		break;

	case ESqlKeyword_real:

		type=EDbColReal32;

		break;

	case ESqlKeyword_double:

		Parse(ESqlKeyword_precision);

		// fall through

	case ESqlKeyword_float:

		type=EDbColReal64;

		break;

	case ESqlKeyword_date:

	case ESqlKeyword_time:

	case ESqlKeyword_timestamp:

		type=EDbColDateTime;

		break;

	case ESqlKeyword_char:

	case ESqlKeyword_varchar:

		type=EDbColText;

		break;

	case ESqlKeyword_char8:

	case ESqlKeyword_varchar8:

		type=EDbColText8;

		break;

	case ESqlKeyword_binary:

	case ESqlKeyword_varbinary:

		type=EDbColBinary;

		break;

	case ESqlKeyword_unsigned:	// unsigned tinyint, smallint or integer

		switch (Keyword())

			{

		case ESqlKeyword_tinyint:

			type=EDbColUint8;

			break;

		case ESqlKeyword_smallint:

			type=EDbColUint16;

			break;

		case ESqlKeyword_integer:

			type=EDbColUint32;

			break;

		default:

			return SqlErrorL();

			};

		break;

	case ESqlKeyword_long:		// varchar or varbinary

		switch (Keyword())

			{

		case ESqlKeyword_varchar8:

			type=EDbColLongText8;

			break;

		case ESqlKeyword_varchar:

			type=EDbColLongText;

			break;

		case ESqlKeyword_varbinary:

			type=EDbColLongBinary;

			break;

		default:

			return SqlErrorL();

			};

		break;

	default:

		return SqlErrorL();

		}

	aDef.iType=type;

//

// get any optional length

	aDef.iMaxLength=KDbUndefinedLength;

	TSqlTokenType t=iToken.Type();

	switch (type)

		{

	case EDbColText:

	case EDbColBinary:

		if (t==ESqlLeftBracket)

			{

			if (NextToken()==ESqlLiteralInt)

				{

				iToken.Literal().ToInt32L();

				aDef.iMaxLength=iToken.Literal().Int32();

				NextToken();

				t=RightBracketL();

				}

			else

				return SqlErrorL();

			}

		break;

	default:

		break;

		}

	return t;

	}

CSqlSearchCondition* TSqlParser::SearchCondition(TInt aNot)

//

// Parse a search-condition

//

	{

	CSqlSearchCondition* left=BooleanTerm(aNot);

	if (left==0 || Parse(ESqlKeyword_or)==ESqlNoToken)

		return left;

	return CSqlMultiNode::New(aNot ? CSqlMultiNode::EAnd : CSqlMultiNode::EOr,left,SearchCondition(aNot));

	}

CSqlSearchCondition* TSqlParser::BooleanTerm(TInt aNot)

//

// Parse a boolean-term

//

	{

	CSqlSearchCondition* left=BooleanFactor(aNot);

	if (left==0 || Parse(ESqlKeyword_and)==ESqlNoToken)

		return left;

	return CSqlMultiNode::New(aNot ? CSqlMultiNode::EOr : CSqlMultiNode::EAnd,left,BooleanTerm(aNot));

	}

CSqlSearchCondition* TSqlParser::BooleanFactor(TInt aNot)

//

// Parse a boolean-factor

//

	{

	while (Parse(ESqlKeyword_not))

		aNot=~aNot;

	return BooleanPrimary(aNot);

	}

CSqlSearchCondition* TSqlParser::BooleanPrimary(TInt aNot)

//

// Parse a boolean-factor

//

	{

	// brackets only allowed in this element, so this ordering is valid

	if (iToken!=ESqlLeftBracket)

		return Predicate(aNot);

	// bracketed search condition

	NextToken();

	CSqlSearchCondition* node=SearchCondition(aNot);

	if (!node)

		return node;

	if (iToken==ESqlRightBracket)

		{

		NextToken();

		return node;

		}

	delete node;

	return SqlError();

	}

CSqlSearchCondition* TSqlParser::Predicate(TInt aNot)

//

// Parse predicate

// On null return, error will already be set

//

	{

	if (iToken!=ESqlIdentifier)	// column name

		return SqlError();

	TPtrC column(iToken.Literal().DesC());

	TSqlTokenType t=NextToken();

	if (t==ESqlIdentifier)

		{	// like-predicate or null-predicate

		switch (Keyword())

			{

		case ESqlKeyword_is:	// IS [NOT] NULL

			if (Parse(ESqlKeyword_not))

				aNot=~aNot;

			if (Parse(ESqlKeyword_null)==ESqlNoToken)

				return SqlError();

			return new CSqlNullPredicate(aNot ? CSqlNullPredicate::EIsNotNull : CSqlNullPredicate::EIsNull,column);

		case ESqlKeyword_not:	// NOT LIKE

			if (Parse(ESqlKeyword_like)==ESqlNoToken)

				return SqlError();

			aNot=~aNot;

			// drop through to Like

		case ESqlKeyword_like:	// LIKE

			{

			if (iToken!=ESqlLiteralText)

				return SqlError();

			//Following code is for the implementation of limited-ESCAPE-clause 

			const TText *next = iSql.Next(); 

			TPtrC pattern(iToken.Literal().DesC());

			RSqlLiteral tmp = iToken.Literal();

			NextToken(); // Searching for ESCAPE Key word

			if (Keyword() == ESqlKeyword_escape)

				{

				TInt length = pattern.Length();

				if (length <= 0 || length > (KMaxSegmentLength + 2 ))

					return SqlError();

				TPtrC escapeChar(iToken.Literal().DesC());

				if (escapeChar.Length() <= 0)

					return SqlError();

				TChar escchar = escapeChar[0];

				TText newPattern[KMaxSegmentLength + 2]; // '*' can come as first and last char

				TInt count = PatternFilter(pattern,escchar, newPattern);

				if (count <=0 )

					return SqlError();

				iToken.Literal().SetText(newPattern,(newPattern + count));

				// copy the text to RSqlLiteral as newpattern could go out of scope

				if (iToken.Literal().CopyText() != KErrNone)

					{

					return SqlError();

					}

				CSqlSearchCondition* node = new CSqlLikePredicate(aNot ? CSqlLikePredicate::ENotLike : CSqlLikePredicate::ELike,column,iToken.Literal());

				if (node)

					{

					NextToken();

					node->iIsEscape = ETrue;

					}

				return node;						

				}

			else

				{

				//Setto the previous node

				iSql.Set(next);

				CSqlSearchCondition* node = new CSqlLikePredicate(aNot ? CSqlLikePredicate::ENotLike : CSqlLikePredicate::ELike,column,tmp);

				if(node)

					NextToken();

				return node;

				}

			}

		default:

			return SqlError();

			}

		}

	// Comparison predicate...

	CSqlSearchCondition::TType op;

	switch (t)

		{

	case ESqlGreaterEqual:

		aNot=~aNot;

		// drop through to less

	case ESqlLess:

		op=aNot ? CSqlSearchCondition::EGreaterEqual : CSqlSearchCondition::ELess;

		break;

	case ESqlGreater:

		aNot=~aNot;

		// drop through to less equal

	case ESqlLessEqual:

		op=aNot ? CSqlSearchCondition::EGreater: CSqlSearchCondition::ELessEqual;

		break;

	case ESqlNotEqual:

		aNot=~aNot;

		// drop through to equal

	case ESqlEqual:

		op=aNot ? CSqlSearchCondition::ENotEqual : CSqlSearchCondition::EEqual;

		break;

	default:

		return SqlError();

		}

	t=NextToken();

	if (t!=ESqlLiteralInt && t!=ESqlLiteralReal && 

			t!=ESqlLiteralTime && t!=ESqlLiteralText &&

			t!=ESqlLiteralBlob )

		return SqlError();

	CSqlSearchCondition* node=new CSqlCompPredicate(op,column,iToken.Literal());

	if (node)

		NextToken();

	return node;

	}

CSqlSearchCondition* TSqlParser::SearchConditionL()

//

// Parse a search-condition

//

	{

	CSqlSearchCondition* sc=SearchCondition(0);

	if (!sc)

		{

		__LEAVE_IF_ERROR(Error());	// syntax error

		User::LeaveNoMemory();		// otherwise a OOM error

		}

	return sc;

	}

void TSqlParser::SortSpecificationL(CDbKey& aKey)

//

// Parse a sort-specification

//

	{

	for (;;)

		{

		TDbKeyCol col(IdentifierL());

		NextToken();

		if (Parse(ESqlKeyword_desc))

			col.iOrder=col.EDesc;

		else

			{

			Parse(ESqlKeyword_asc);

			col.iOrder=col.EAsc;

			}

		aKey.AddL(col);

		if (iToken!=ESqlComma)

			break;

		NextToken();

		}

	}

CSqlQuery* TSqlParser::QueryLC()

//

// Generate a CSqlQuery

//

	{

	CSqlQuery* query=new(ELeave) CSqlQuery;

	CleanupStack::PushL(query);

	if (ParseL(ESqlKeyword_select)==ESqlAsterisk)

		NextToken();

	else

		ColumnListL(query->iColumns);

	ParseL(ESqlKeyword_from);

	IdentifierL(query->iTable);

	if (Parse(ESqlKeyword_where))

		query->iSearchCondition=SearchConditionL();

	if (Parse(ESqlKeyword_order))

		{

		ParseL(ESqlKeyword_by);

		SortSpecificationL(query->SortSpecificationL());

		}

	EndL();

	return query;

	}

CSqlSearchCondition* TSqlParser::SearchConditionLC()

//

// Parse a standalone search-condition

//

	{

	CSqlSearchCondition* sc=SearchConditionL();

	CleanupStack::PushL(sc);

	EndL();

	return sc;

	}

CSqlDDLStatement* TSqlParser::CreateTableLC()

//

// Parse a CREATE TABLE statement

//

	{

	CSqlCreateTableStatement* statement=new(ELeave) CSqlCreateTableStatement;

	CleanupStack::PushL(statement);

	IdentifierL(statement->iName);

	ParseL(ESqlLeftBracket);

	TDbCol def;

	for (;;)

		{

		AddColumnSpecL(def);

		if (Parse(ESqlKeyword_not))

			{

			ParseL(ESqlKeyword_null);

			def.iAttributes|=TDbCol::ENotNull;

			}