/* ......................................................... -*- java -*-
 * FILE: SqlScript.jjt (derived from FormsPlSql.jj)                    *
 *                                                                     *
 * DESCRIPTION: This file contains the entire grammar for PLSQL inside *
 * Oracle*Forms 4.5(i.e. PlSql 1.x)                                    *
 *                                                                     *
 * HISTORY: 07-APR-1997 Created  Ramanathan .S (sramji@rocketmail.com) *
 *                                                                     *
 * NOTE: Read the file FormsPlSql.readme for more info                 *
 *                                                                     *
 * MODIFIED: 11-JAN-2003 Guido Draheim                                 *
 *           expanding the grammar to understand proper SQL scripts    *
 *           including a bunch of scripts made in the postgres flavour *
 *           and washing it up to create a nice JJTree representation  *
 * ................................................................... */


options{
    IGNORE_CASE=true ;
//  DEBUG_LOOKAHEAD= true ;
}

PARSER_BEGIN(SqlScript)

import java.io.* ;

class SqlScript {
    public static void main( String args[] )
        throws ParseException
        {

        SqlScript p = null ;
        if ( args.length < 1  ) {
            System.out.println("Reading from stdin") ;
            p = new SqlScript(System.in) ;
        }
        else {
            try {
                p = new SqlScript(new DataInputStream(
                                new FileInputStream(args[0]))) ;
            }
            catch (FileNotFoundException e) {
                System.out.println("File " + args[0] +
                                " not found. Reading from stdin") ;
                p = new SqlScript(System.in) ;
            }
        } // else ends here

        if ( args.length > 0 ) {
            System.out.println(args[0]) ;
        }
        SimpleNode t = p.SQLScript() ;
        System.out.println("Parse Successfull") ;
	t.dump(">");

    } // main ends here
} // class SqlScript ends here

class SqlValue extends SimpleNode
{
    String value;
    public SqlValue(String _value) { super(0); value = _value; }
    public String toString() { return ":"+value; }
}

PARSER_END(SqlScript)


SKIP:
{
    " "
|   "\t"
|   "\r"
|   "\n"
}

/* Prefix      Meaning
    -------------------
    K_          Keyword
    O_          Operator
    S_          Substitutes
*/

TOKEN: /* SQL and PLSQL Keywords. prefixed with K_ to avoid name clashes */
{
    <K_ALL: "ALL">
|   <K_AND: "AND">
|   <K_ANY: "ANY">
|   <K_AS: "AS">
|   <K_ASC:"ASC">
|   <K_BEGIN: "BEGIN">
|   <K_BETWEEN:"BETWEEN">
|   <K_BINARY_INTEGER: "BINARY_INTEGER">
|   <K_BOOLEAN:"BOOLEAN">
|   <K_BY:"BY">
|   <K_CHAR:"CHAR">
|   <K_CLOSE:"CLOSE">
|   <K_COMMENT:"COMMENT">
|   <K_COMMIT:"COMMIT">
|   <K_CONNECT:"CONNECT">
|   <K_CONSTANT:"CONSTANT">
|   <K_CURRENT:"CURRENT">
|   <K_CURSOR:"CURSOR">
|   <K_DATE:"DATE">
|   <K_DECIMAL:"DECIMAL">
|   <K_DECLARE:"DECLARE">
|   <K_DEFAULT:"DEFAULT">
|   <K_DELETE:"DELETE">
|   <K_DESC:"DESC">
|   <K_DISTINCT:"DISTINCT">
|   <K_DO:"DO">
|   <K_ELSE:"ELSE">
|   <K_ELSIF:"ELSIF">
|   <K_END:"END">
|   <K_EXCEPTION:"EXCEPTION">
|   <K_EXCEPTION_INIT:"EXCEPTION_INIT">
|   <K_EXCLUSIVE:"EXCLUSIVE">
|   <K_EXISTS:"EXISTS">
|   <K_EXIT:"EXIT">
|   <K_FETCH:"FETCH">
|   <K_FLOAT:"FLOAT">
|   <K_FOR:"FOR">
|   <K_FROM:"FROM">
|   <K_FUNCTION:"FUNCTION">
|   <K_GOTO:"GOTO">
|   <K_GROUP:"GROUP">
|   <K_HAVING:"HAVING">
|   <K_IF:"IF">
|   <K_IN:"IN">
|   <K_INDEX:"INDEX">
|   <K_INSERT:"INSERT">
|   <K_INTEGER:"INTEGER">
|   <K_INTERSECT:"INTERSECT">
|   <K_INTO:"INTO">
|   <K_IS:"IS">
|   <K_JOIN:"JOIN">
|   <K_LEVEL:"LEVEL">
|   <K_LIKE:"LIKE">
|   <K_LOCK:"LOCK">
|   <K_LOOP:"LOOP">
|   <K_MINUS:"MINUS">
|   <K_MODE:"MODE">
|   <K_NATURAL:"NATURAL">
|   <K_NOT:"NOT">
|   <K_NOWAIT:"NOWAIT">
|   <K_NULL:"NULL">
|   <K_NUMBER:"NUMBER">
|   <K_OF:"OF">
|   <K_ONLY:"ONLY">
|   <K_OPEN:"OPEN">
|   <K_OR:"OR">
|   <K_ON:"ON">
|   <K_ORDER:"ORDER">
|   <K_OTHERS:"OTHERS">
|   <K_OUT:"OUT">
|   <K_PACKAGE:"PACKAGE">
|   <K_POSITIVE:"POSITIVE">
|   <K_PRAGMA:"PRAGMA">
|   <K_PRIOR:"PRIOR">
|   <K_PROCEDURE:"PROCEDURE">
|   <K_RAISE:"RAISE">
|   <K_READ:"READ">
|   <K_REAL:"REAL">
|   <K_RECORD:"RECORD">
|   <K_REF:"REF">
|   <K_RETURN:"RETURN">
|   <K_REVERSE:"REVERSE">
|   <K_ROLLBACK:"ROLLBACK">
|   <K_ROW:"ROW">
|   <K_SAVEPOINT:"SAVEPOINT">
|   <K_SEGMENT:"SEGMENT">
|   <K_SELECT:"SELECT">
|   <K_SET:"SET">
|   <K_SHARE:"SHARE">
|   <K_SMALLINT:"SMALLINT">
|   <K_SQL:"SQL">
|   <K_START:"START">
|   <K_TABLE:"TABLE">
|   <K_THEN:"THEN">
|   <K_TO:"TO">
|   <K_TRANSACTION:"TRANSACTION">
|   <K_UNION:"UNION">
|   <K_UPDATE:"UPDATE">
|   <K_USE:"USE">
|   <K_VALUES:"VALUES">
|   <K_VARCHAR2:"VARCHAR2">
|   <K_VARCHAR:"VARCHAR">
|   <K_WHEN:"WHEN">
|   <K_WHERE:"WHERE">
|   <K_WHILE:"WHILE">
|   <K_WITH:"WITH">
|   <K_WORK:"WORK">
|   <K_WRITE:"WRITE">
}

TOKEN : /* Numeric Constants */
{
	< S_NUMBER: <FLOAT>
	    | <FLOAT> ( ["e","E"] ([ "-","+"])? <FLOAT> )?
    	>
  | 	< #FLOAT: <INTEGER>
	    | <INTEGER> ( "." <INTEGER> )?
	    | "." <INTEGER>
    	>
  | 	< #INTEGER: ( <DIGIT> )+ >
  | 	< #DIGIT: ["0" - "9"] >
}

SPECIAL_TOKEN:
{
   <LINE_COMMENT: "--"(~["\r","\n"])*>
|  <MULTI_LINE_COMMENT: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
}


TOKEN:
{
	< S_IDENTIFIER: ( <LETTER> )+ ( <DIGIT> | <LETTER> |<SPECIAL_CHARS>)* >
| 	< #LETTER: ["a"-"z", "A"-"Z"] >
|   < #SPECIAL_CHARS: "$" | "_">
|   < S_BIND: ":" <S_IDENTIFIER> ("." <S_IDENTIFIER>)? >
|   < S_CHAR_LITERAL: "'" (~["'"])* "'" ("'" (~["'"])* "'")*>
|   < S_QUOTED_IDENTIFIER: "\"" (~["\n","\r","\""])* "\"" >
}

void S_Identifier() :
{ Token t; } 
{ t=<S_IDENTIFIER> { jjtThis.jjtAddChild(new SqlValue(t.image), 0); } }
void S_Quoted_Identifier() :
{ Token t; } 
{ t=<S_QUOTED_IDENTIFIER> { jjtThis.jjtAddChild(new SqlValue(t.image), 0); } }
void S_Char_Literal() :
{ Token t; } 
{ t=<S_CHAR_LITERAL> { jjtThis.jjtAddChild(new SqlValue(t.image), 0); } }

SimpleNode SQLScript():
{}
{
    (SQLScriptStatements())+ { return jjtThis; }
}

void SQLScriptStatements() #void :
{}
{
    SQLStatement() | FunctionDeclaration()
}

/* Represents a PLSQL code block. */
void CompilationUnit():
{}
{
    ProcedureDeclaration()
|   FunctionDeclaration()
|   SequenceOfStatements()
}

void DeclarationSection():
{}
{
    "DECLARE" Declarations()

}

void Declarations():
{}
{

    (( IdentifierDeclaration() // Variable or Constant Declaration
       |
       CursorDeclaration()
       |
       PragmaDeclaration()
     )
     ";"
    )+

    ( ProcedureDeclaration()
      |
      FunctionDeclaration()
    )*
}

void IdentifierDeclaration():
{}
{
    RelObjectName()

    ( ConstantDeclaration()
      |
      VariableDeclaration()
      |
      ExceptionDeclaration()
    )
}

void CursorDeclaration():
{}
{
   "CURSOR" RelObjectName() ["(" ParameterList() ")" ]
        "IS" SelectStatement()
}

void ProcedureDeclaration():
{}
{
    "PROCEDURE" RelObjectName() [ "(" ParameterList() ")" ]
    ( ";"  // Procedure Specification
      |
      "IS" ProcedureBody()
    )
}

void ProcedureBody():
{}
{
    [ Declarations() ]
    BeginEndBlock()
}

void FunctionDeclaration():
{}
{
    "FUNCTION" RelObjectName() [ "(" ParameterList() ")" ]
    "RETURN" TypeDeclaration()
    ( ";" // FunctionSpecification
      |
      "IS" FunctionBody()
    )
}

void FunctionBody() #void :
{}
{
    [ Declarations() ]
    BeginEndBlock()
}

void PragmaDeclaration():
{}
{
    "PRAGMA" "EXCEPTION_INIT" "(" NumOrID() "," NumOrID() ")"
}

void VariableDeclaration():
{}
{
    TypeDeclaration() [ "NOT" "NULL" ]
                        [ (":=" | "DEFAULT" ) PlSqlExpression() ]
}

void ConstantDeclaration():
{}
{
    "CONSTANT" TypeDeclaration() [ "NOT" "NULL" ]
                        (":=" | "DEFAULT" ) PlSqlExpression()
}

void TypeDeclaration():
{}
{
    BasicDataTypeDeclaration()
    |
    LOOKAHEAD(2) (RelObjectName() ("%TYPE" | "%ROWTYPE"))
    |
    LOOKAHEAD(TableColumn() "%TYPE")TableColumn()"%TYPE"
    |
    RelObjectName()  // For Alert declarations etc, in Forms
}



void BasicDataTypeDeclaration():
{}
{
    (       "CHAR"
        |   "VARCHAR"
        |   "VARCHAR2"
        |   "INTEGER"
        |   "NUMBER"
        |   "NATURAL"
        |   "REAL"
        |   "FLOAT"
    ) [ "(" <S_NUMBER> [ "," <S_NUMBER> ] ")" ]

    |   "DATE"
    |   "BINARY_INTEGER"
    |   "BOOLEAN"
}


void ExceptionDeclaration():
{}
{
    "EXCEPTION"
}

/* ---------------- DECLARATIONS SECTION ends here ------------------ */

/* ---------------- Code Section starts here ---------------------- */
                                
void BeginEndBlock():
{}
{
    "BEGIN"
    SequenceOfStatements()
    [ ExceptionBlock()]
    "END" [RelObjectName()] ";"
}

void SequenceOfStatements():
{}
{
    (PLSQLStatement())+
}

void ExceptionBlock():
{}
{
    "EXCEPTION"
    (ExceptionHandler())+
}

void ExceptionHandler():
{}
{
    "WHEN" ( RelObjectName() ("OR" RelObjectName())*
             |
             "OTHERS"
           )
    "THEN" SequenceOfStatements()
}

void PLSQLStatement():
{}
{
    LOOKAHEAD(SubroutineCall()) SubroutineCall()
    |
    AssignmentStatement()
    |
    ExitStatement()
    |
    GotoStatement()
    |
    IfStatement()
    |
    LoopStatement()
    |
    NullStatement()
    |
    RaiseStatement()
    |
    ReturnStatement()
    |
    SQLStatement()
    |
    LabelDeclaration()
    |
    [DeclarationSection()] BeginEndBlock()
}

void LabelDeclaration():
{}
{
    "<<" RelObjectName() ">>"
}

void SQLStatement() #void :
{}
{
    CloseStatement()
    |
    CommitStatement()
    |
    DeleteStatement()
    |
    FetchStatement()
    |
    InsertStatement()
    |
    LockTableStatement()
    |
    OpenStatement()
    |
    RollbackStatement()
    |
    SavepointStatement()
    |
    QueryStatement()
    |
    SetStatement()
    |
    UpdateStatement()
}

void SubroutineCall():
{}
{
    RelObjectName() ["." DotObjectName()] [ "(" Arguments() ")" ] ";"
}

void AssignmentStatement():
{}
{
      // <var> = <value> and <cursor>.<var> = <value>
    ( (RelObjectName() ["." DotObjectName()] ":=" PlSqlExpression())
      |
      (<S_BIND> ":=" PlSqlExpression())
    )
    ";"
}


void ExitStatement():
{}
{
    "EXIT" [ RelObjectName()] ["WHEN" PlSqlExpression()] ";"
}

void GotoStatement():
{}
{
    "GOTO" RelObjectName() ";"
}

void IfStatement():
{}
{
    "IF" PlSqlExpression()
    "THEN"
          SequenceOfStatements()
    ("ELSIF" PlSqlExpression()
     "THEN"
             SequenceOfStatements()
    )*
    ["ELSE"
            SequenceOfStatements()
    ]
    "END" "IF" [RelObjectName()] ";"
}

void LoopStatement():
{}
{
    NormalLoop()
    |
    WhileLoop()
    |
    ForLoop()
}

void NormalLoop():
{}
{
    "LOOP"
        SequenceOfStatements()
    "END" "LOOP" [RelObjectName()] ";"
}

void WhileLoop():
{}
{
    "WHILE"  PlSqlExpression()
     NormalLoop()
}

void ForLoop():
{}
{
    LOOKAHEAD(NumericForLoopLookahead())
    NumericForLoop()
    |
    CursorForLoop()
}

void NumericForLoopLookahead():
{}
{
    "FOR" RelObjectName() "IN" ["REVERSE"]
          PlSqlSimpleExpression() ".."
}

void NumericForLoop():
{}
{
    "FOR" RelObjectName() "IN" ["REVERSE"]
          PlSqlSimpleExpression() ".." PlSqlSimpleExpression()
    NormalLoop()

}

void CursorForLoop():
{}
{
  "FOR" RelObjectName() "IN" ( RelObjectName() [ "(" Arguments() ")"]
                              | "(" SelectStatement() ")"
                            )
  NormalLoop()
}

void NullStatement():
{}
{
    "NULL" ";"
}

void RaiseStatement():
{}
{
    "RAISE" [RelObjectName()] ";"
}


void ReturnStatement():
{}
{
    "RETURN" [ PlSqlExpression() ] ";"
}


void CloseStatement():
{}
{
    "CLOSE" RelObjectName() ";"
}

void CommitStatement():
{}
{
    "COMMIT" ["WORK"] ["COMMENT" S_Char_Literal()] ";"
}

void FetchStatement():
{}
{
    "FETCH" (RelObjectName())
    "INTO" (RelObjectName() | <S_BIND>) ("," (RelObjectName() | <S_BIND>))* ";"
}

void LockTableStatement():
{}
{
    "LOCK" "TABLE" TableReference() ("," TableReference())*
    "IN" LockMode() "MODE" ["NOWAIT"] ";"
}

void OpenStatement():
{}
{
    "OPEN" RelObjectName() ["(" Arguments() ")"] ";"
}

void RollbackStatement():
{}
{
    "ROLLBACK" ["WORK"] ["TO" ["SAVEPOINT"] RelObjectName()]
    ["COMMENT" S_Char_Literal()] ";"
}

void SetTransactionStatement():
{}
{
    "SET" "TRANSACTION" (("READ" ("ONLY" | "WRITE"))
                          |("USE" "ROLLBACK" "SEGMENT" RelObjectName())
                        )
    ";"
}

void SetVariableStatement():
{}
{
    "SET" RelObjectName() "TO" Arguments() ";"
}

void SetStatement() #void :
{}
{
    LOOKAHEAD(SetTransactionStatement()) SetTransactionStatement()
|   SetVariableStatement()
}

void LockMode():
{}
{
    ("ROW" ("SHARE" | "EXCLUSIVE"))
|   ("SHARE" ["UPDATE" | ("ROW" "EXCLUSIVE")])
|   ("EXCLUSIVE")
}

void SavepointStatement():
{}
{
    "SAVEPOINT" RelObjectName() ";"
}

void UpdateStatement():
{}
{
    "UPDATE" TableReference() [RelObjectName()]
    "SET" ColumnValues()
   [ "WHERE" ( SQLExpression() | "CURRENT" "OF" RelObjectName())] ";"
}

void ColumnValues():
{}
{
  TableColumn() "=" UpdatedValue()
  ("," TableColumn() "=" UpdatedValue())*
}

void UpdatedValue(): // Can be a subquery or a expression
{}
{
  LOOKAHEAD(("(")+ "SELECT")
  "(" SelectStatement() ")"
  |
  PlSqlExpression()
}

void InsertStatement():
{}
{
    "INSERT" "INTO" TableReference()
     [ "(" TableColumn() ("," TableColumn())* ")" ]
    ( "VALUES" "(" PlSqlExpressionList() ")"
      |
      SelectStatement()
    )

    ";"
}


void DeleteStatement():
{}
{
    "DELETE" ["FROM"] TableReference() [RelObjectName()]
    ["WHERE" (SQLExpression() | "CURRENT" "OF" RelObjectName() ) ] ";"
}


void QueryStatement():
{}
{
    SelectStatement()
    ";"
}

// PLSQL Expression and it's childs

void PlSqlExpression():
{}
{
    PlSqlExpressions()
}

void PlSqlExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlOrExpression()) PlSqlOrExpression()
|   PlSqlAndExpressions()
}

void PlSqlOrExpression():
{}
{
    PlSqlAndExpressions() ("OR" PlSqlAndExpressions())+
}

void PlSqlAndExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlAndExpression()) PlSqlAndExpression()
|   PlSqlUnaryLogicalExpressions()
}

void PlSqlAndExpression():
{}
{
    PlSqlUnaryLogicalExpressions() ( "AND" PlSqlUnaryLogicalExpressions())+
}

void PlSqlUnaryLogicalExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlUnaryLogicalExpression()) PlSqlUnaryLogicalExpression()
|   PlSqlRelationalExpressions()
}

void PlSqlUnaryLogicalExpression():
{}
{
  "NOT" PlSqlRelationalExpressions()
}

void PlSqlRelationalExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlRelationalExpression()) PlSqlRelationalExpression()
|   PlSqlSimpleExpressions()
}

void PlSqlRelationalExpression():
{}
{
    PlSqlSimpleExpressions()

    ( Relop() PlSqlSimpleExpressions()
      |
      LOOKAHEAD(2) PlSqlInClause()
      |
      LOOKAHEAD(2) PlSqlBetweenClause()
      |
      LOOKAHEAD(2) PlSqlLikeClause()
      |
      IsNullClause()
   )
}

void PlSqlExpressionList():
{}
{
    PlSqlExpression() ("," PlSqlExpression())*
}

void PlSqlInClause():
{}
{
    ["NOT"] "IN" "(" PlSqlExpressionList()")"
}

void PlSqlBetweenClause():
{}
{
    ["NOT"] "BETWEEN" PlSqlSimpleExpressions() "AND" PlSqlSimpleExpressions()
}

void PlSqlLikeClause():
{}
{
    ["NOT"] "LIKE" PlSqlSimpleExpressions()
}

void IsNullClause():
{}
{
    "IS" ["NOT"] "NULL"
}


void PlSqlSimpleExpression():
{}
{
    PlSqlSimpleExpressions() 
}

void PlSqlSimpleExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlAdditiveExpression()) PlSqlAdditiveExpression()
|   PlSqlMultiplicativeExpressions() 
}

void PlSqlAdditiveExpression():
{}
{
    PlSqlMultiplicativeExpressions() ( ("+" | "-" | "||")
                                 PlSqlMultiplicativeExpressions()
                               )+
}

void PlSqlMultiplicativeExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlMultiplicativeExpression()) PlSqlMultiplicativeExpression()
|   PlSqlExpotentExpressions()
}

void PlSqlMultiplicativeExpression():
{}
{
    PlSqlExpotentExpressions() ( ("*" | "/") PlSqlExpotentExpressions())+
}

void PlSqlExpotentExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlExpotentExpression()) PlSqlExpotentExpression()
|   PlSqlUnaryExpressions()
}

void PlSqlExpotentExpression():
{}
{
    PlSqlUnaryExpressions() ( "**" PlSqlUnaryExpressions())+
}

void PlSqlUnaryExpressions() #void :
{}
{
    LOOKAHEAD(PlSqlUnaryExpression()) PlSqlUnaryExpression()
|
    PlSqlPrimaryExpression()
}

void PlSqlUnaryExpression():
{}
{
    (("+" | "-") PlSqlPrimaryExpression())
}


void PlSqlPrimaryExpression():
{}
{

    "NULL"
    | LOOKAHEAD(2)
    (RelObjectName() ("%FOUND" | "%NOTFOUND" | "%ISOPEN" | "%ROWCOUNT"))
    | LOOKAHEAD(2)
    (RelObjectName() "(" Arguments() ")" )
    |
    (RelObjectName() ["." DotObjectName()])  // cursor.var
    |
    ("SQL" ("%FOUND" | "%NOTFOUND" | "%ISOPEN" | "%ROWCOUNT"))
    |
    <S_NUMBER>
    |
    <S_BIND>
    |
    "(" PlSqlExpression() ")"
}

/* ----------------------- PLSQL Code Block Ends here -------------- */

/* ---------------- General Productions --------------------- */

void TableColumn():
{}
{
    // user.table.column
    RelObjectName() [ "." DotObjectName() ["." DotObjectName()]]
}

void RelObjectName() #ObjectName :
{ Token t; }
{
    t=<S_IDENTIFIER>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<S_QUOTED_IDENTIFIER>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<S_CHAR_LITERAL>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
}

void DotObjectName() #ObjectName :  // only put after "." match
{ Token t; }                        // here we list some char-sequences that 
{                                   // would be returned as a special token
    t=<S_IDENTIFIER>                // but they are not special here
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<S_QUOTED_IDENTIFIER>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<S_CHAR_LITERAL>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_ASC>                  
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_BETWEEN>              
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_BINARY_INTEGER>       
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_BOOLEAN>              
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_CHAR>                 
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_CLOSE>                
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_COMMENT>              
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_COMMIT>               
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_CONNECT>              
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_CONSTANT>             
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_CURRENT>              
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_CURSOR>               
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_DATE>                 
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_DECIMAL>              
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_DECLARE>              
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_DELETE>               
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_DESC>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_DISTINCT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_EXCEPTION>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_EXCEPTION_INIT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_EXCLUSIVE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_EXISTS>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_EXIT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_FETCH>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_FLOAT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_FUNCTION>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_GOTO>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_GROUP>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_HAVING>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_INDEX>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_INSERT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_INTEGER>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_INTERSECT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_INTO>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_JOIN>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_LEVEL>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_LIKE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_LOOP>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_MINUS>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_MODE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_NATURAL>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_NOWAIT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_NUMBER>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_ONLY>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_OPEN>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_ORDER>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_OTHERS>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_PACKAGE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_POSITIVE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_PRAGMA>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_PRIOR>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_PROCEDURE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_RAISE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_READ>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_REAL>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_RECORD>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_RETURN>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_REVERSE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_ROLLBACK>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_SAVEPOINT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_SEGMENT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_SELECT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_SHARE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_SMALLINT>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_START>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_TABLE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_THEN>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_TRANSACTION>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_UNION>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_UPDATE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_VALUES>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_VARCHAR2>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_VARCHAR>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_WHERE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_WORK>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
|   t=<K_WRITE>
    { jjtThis.jjtAddChild(new SqlValue(t.image), 0); }//SqlValue
}

void OracleObjectName():  // usually unused now - see above
{}
{
    <S_IDENTIFIER> | <S_QUOTED_IDENTIFIER>
}

void Relop():
{}
{
  "=" | "!=" | "#" | "<>" | ">" | ">=" | "<" | "<="
}

void TableReference():
{}
{
    RelObjectName() ["." DotObjectName()]
}

void ParameterList():
{}
{
    Parameter() ( "," Parameter() )*
}

void NumOrID():
{}
{
    <S_IDENTIFIER> | (["+" | "-"] <S_NUMBER>)
}

void Parameter():
{}
{
    RelObjectName() [ ["IN"] ["OUT"] TypeDeclaration()
                             [(":=" | "DEFAULT" ) PlSqlExpression()] ]
}

// Just a synonym for PlSqlExpressionList for better readability
void Arguments():
{}
{
    PlSqlExpressionList()
}

/* --------------- General Productions ends here --------------- */

/* ----------- SQL productions start here ----------------- */

void SelectStatement():
{}
{
    SelectWithoutOrder()
    [ OrderByClause() ]
    [ ForUpdateClause() ]

}

void SelectWithoutOrder():
{}
{
     "SELECT" [ "ALL" | "DISTINCT" ] SelectList()
    [IntoClause()]
    FromClause()
    [ WhereClause() ]
    [ ConnectClause() ]
    [ GroupByClause() ]
    [ SetClause() ]
}


/* Checks for whatever follows  SELECT */
void SelectList():
{}
{
    "*" | SelectItem() ("," SelectItem())*
}

void SelectItem():
{}
{
    //    LOOKAHEAD(SelectAllItems()) SelectAllItems()
    //|   SQLSimpleExpression()    // Column or Expression
    //    [<S_IDENTIFIER>] // Column Alias
    LOOKAHEAD(FunctionCall()) FunctionCall() [AsObjectName()]
|   LOOKAHEAD(SelectAllItems()) SelectAllItems()
|   LOOKAHEAD(TableColumn()) TableColumn() [AsObjectName()] 
|   "<METADATA_ID>" [AsObjectName()]
}

void SelectAllItems():
{}
{   /* table.*  OR schema.table.*  */
    LOOKAHEAD(2)
    RelObjectName() "." "*"
|   RelObjectName() "." DotObjectName() "." "*"
}

void AsObjectName():
{}
{
   RelObjectName() | "AS" DotObjectName()
}

void IntoClause():
{}
{
   "INTO" IntoItem() ("," IntoItem())*
}

void IntoItem():
{}
{
   (RelObjectName() ["." DotObjectName()] )
|  (<S_BIND>)
}

void FromClause():
{}
{
    "FROM" FromItem() ( "," FromItem())*
}

void FromItem():
{}
{
    //  TableReference()
    //  [ <S_IDENTIFIER> ]        /** Alias Name **/
    ( TableReference() | "(" FromItemExpression() ")" )
    ( LOOKAHEAD(JoinerExpression()) JoinerExpression() 
                             ["AS" AsObjectName()] 
                         | [AsObjectName()])
}

void FromItemExpression():
{}
{
    ( TableReference() | "(" FromItemExpression() ")") 
     (JoinerExpression())*
}

void JoinerExpression():
{}
{
   "JOIN" TableReference() [JoinWhereClause()]
|  LOOKAHEAD(2)
   RelObjectName() "JOIN" TableReference() [JoinWhereClause()]
}

void JoinWhereClause():
{}
{
    "ON" SQLExpression()
}

void WhereClause():
{}
{
    "WHERE" SQLExpression()
}

void ConnectClause():
{}
{
    // The following grammar will take 2 "START WITH" expressions
    // which is not correct. But alright, because only valid statements
    // will be given.
   (["START" "WITH" SQLExpression()] "CONNECT" "BY" SQLExpression()
    ["START" "WITH" SQLExpression()])
}

void GroupByClause():
{}
{
    "GROUP" "BY" SQLExpressionList()
    ["HAVING" SQLExpression()]
}

void SetClause():
{}
{
    (("UNION" ["ALL"]) | "INTERSECT" | "MINUS")
    // LOOKAHEAD("(") because Oracle supports "(" after a UNION
    (LOOKAHEAD("(") ("(" SelectWithoutOrder() ")")
        | SelectWithoutOrder()
    )
}

void OrderByClause():
{}
{
    "ORDER" "BY" SQLSimpleExpression() ["ASC" | "DESC" ]
        ("," SQLSimpleExpression() ["ASC" | "DESC"])*
}

void ForUpdateClause():
{}
{
    "FOR" "UPDATE" "OF" TableColumn() ("," TableColumn())*
}

void SQLExpression():
{}
{
    SQLOrExpressions()
}

void SQLOrExpressions() #void :
{}
{
    LOOKAHEAD(SQLOrExpression()) SQLOrExpression()
|   SQLAndExpressions()
}

void SQLOrExpression():
{}
{
    SQLAndExpressions() ("OR" SQLAndExpressions())+
}


void SQLAndExpressions() #void :
{}
{
    LOOKAHEAD(SQLAndExpression()) SQLAndExpression()
|   SQLUnaryLogicalExpressions()
}

void SQLAndExpression():
{}
{
    SQLUnaryLogicalExpressions() ( "AND" SQLUnaryLogicalExpressions())+
}

void SQLUnaryLogicalExpressions() #void :
{}
{
    LOOKAHEAD(2) ExistsClause()
|   SQLRelationalExpressions()
}

void ExistsClause():
{}
{
    ["NOT"] "EXISTS" "(" SubQuery() ")"
}

void SQLRelationalExpressions() # void :
{}
{
    LOOKAHEAD(SQLRelationalExpression()) SQLRelationalExpression()
|  
    /* Only after looking past "(", Expression() and "," we will know that
       it is expression list */
    (LOOKAHEAD(SQLRelopExpression()) SQLRelopExpression()
|
     LOOKAHEAD("(" SQLSimpleExpression() ",") "(" SQLExpressionList() ")"
|
    (LOOKAHEAD(2) SQLPriorExpression() | SQLSimpleExpressions())
)

}

void SQLRelationalExpression() :
{}
{
    /* Only after looking past "(", Expression() and "," we will know that
       it is expression list */

(    LOOKAHEAD("(" SQLSimpleExpression() ",") "(" SQLExpressionList() ")"
|
    (LOOKAHEAD(2) SQLPriorExpression() | SQLSimpleExpressions())
)

    /* Lookahead(2) is required because of NOT IN,NOT BETWEEN and NOT LIKE */
    //(  SQLRelationalOperatorExpression() 
(  LOOKAHEAD(2) (SQLInClause())
|  LOOKAHEAD(2) (SQLBetweenClause())
|  LOOKAHEAD(2) (SQLLikeClause())
|  IsNullClause()
)
}

void SQLPriorExpression():
{}
{
    ["NOT"] "PRIOR" SQLSimpleExpressions()
}

void SQLExpressionList():
{}
{
    SQLSimpleExpression() ("," SQLSimpleExpression())*
}

void SQLRelopExpression():
{}
{
(    LOOKAHEAD("(" SQLSimpleExpression() ",") "(" SQLExpressionList() ")"
|
    (LOOKAHEAD(2) SQLPriorExpression() | SQLSimpleExpressions())
)


    Relop()

    /* Only after seeing an ANY/ALL or "(" followed by a SubQuery() we can
    determine that is is a sub-query
    */
    (   LOOKAHEAD("ANY" | "ALL" | "(" "SELECT")
        (["ALL" | "ANY"] "(" SubQuery() ")")
    |
        LOOKAHEAD(2) SQLPriorExpression()
    |    
        SQLSimpleExpressions()
    )
}

void SQLRelationalOperatorExpression():
{}
{

    Relop()

    /* Only after seeing an ANY/ALL or "(" followed by a SubQuery() we can
    determine that is is a sub-query
    */
    (   LOOKAHEAD("ANY" | "ALL" | "(" "SELECT")
        (["ALL" | "ANY"] "(" SubQuery() ")")
    |
        LOOKAHEAD(2) SQLPriorExpression()
    |    
        SQLSimpleExpression()
    )
}

void SQLInClause():
{}
{
    ["NOT"] "IN" "(" (SQLExpressionList() | SubQuery()) ")"
}

void SQLBetweenClause():
{}
{
    ["NOT"] "BETWEEN" SQLSimpleExpression() "AND" SQLSimpleExpression()
}

void SQLLikeClause():
{}
{
    ["NOT"] "LIKE" SQLSimpleExpression()
}

void SQLSimpleExpression():
{}
{
    SQLSimpleExpressions()
}

void SQLSimpleExpressions() #void :
{}
{
    SQLAdditiveExpressions()
}

void SQLAdditiveExpressions() #void :
{}
{
    LOOKAHEAD(SQLAdditiveExpression()) SQLAdditiveExpression()
|
    SQLMultiplicativeExpressions()
}

void SQLAdditiveExpression():
{}
{
    SQLMultiplicativeExpressions() ( ("+" | "-" | "||") SQLMultiplicativeExpressions())+
}

void SQLMultiplicativeExpressions() #void :
{}
{
    LOOKAHEAD(SQLMultiplicativeExpression()) SQLMultiplicativeExpression()
|   SQLExpotentExpressions()
}

void SQLMultiplicativeExpression():
{}
{
    SQLExpotentExpressions() ( ("*" | "/") SQLExpotentExpressions())+
}

void SQLExpotentExpressions() #void :
{}
{
    LOOKAHEAD(SQLExpotentExpression()) SQLExpotentExpression()
|   SQLUnaryExpressions()
}

void SQLExpotentExpression():
{}
{
    SQLUnaryExpressions() ( "**" SQLUnaryExpressions())+
}

void SQLUnaryExpressions() #void :
{}
{
    LOOKAHEAD(SQLUnaryExpression()) SQLUnaryExpression()
|   SQLPrimaryExpression()
}

void SQLUnaryExpression():
{}
{
    ("+" | "-") SQLPrimaryExpression()
}

void SQLPrimaryExpression():
{}
{

    "NULL"
|    LOOKAHEAD(FunctionCall()) FunctionCall()
|    LOOKAHEAD(OuterJoinExpression()) OuterJoinExpression()
|    TableColumn() 	// |   <S_CHAR_LITERAL>
|   <S_NUMBER>
|   <S_BIND>
|   "(" SQLExpression() ")"
}

void FunctionCall():
{}
{
    // caters the following
    // function(args)
    // package.function(args)
    // user.package.function(args)

    // however note that "distinct/all/*" can be only used with
    // inbuilt functions but no distinction is made between inbuilt
    // function and custom functions

    RelObjectName() [ "." DotObjectName() ["." DotObjectName()]]
    "(" [ ["DISTINCT" | "ALL"] (SQLArguments() | "*") ] ")"
}

void SQLArguments():
{}
{
    SQLExpressionList()
}


void OuterJoinExpression():
{}
{
    // user.table.col
    RelObjectName() [ "." DotObjectName() ["." DotObjectName()]]
    "(" "+" ")"
}

void SubQuery():
{}
{
    SelectWithoutOrder()
}