JSqlParserCC.jjt

/*
 * #%L
 * JSQLParser library
 * %%
 * Copyright (C) 2004 - 2021 JSQLParser
 * %%
 * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
 * #L%
 */

options {
    IGNORE_CASE = true;
    STATIC = false;
    DEBUG_PARSER = false;
    DEBUG_LOOKAHEAD = false;
    DEBUG_TOKEN_MANAGER = false;
    CACHE_TOKENS = false;
//  FORCE_LA_CHECK = true;
    UNICODE_INPUT = true;
    JAVA_TEMPLATE_TYPE = "modern";
    JDK_VERSION = "1.8";
    TOKEN_EXTENDS = "BaseToken";
    COMMON_TOKEN_ACTION = true;
    NODE_DEFAULT_VOID = true;
    TRACK_TOKENS = true;
    VISITOR = true;
    GRAMMAR_ENCODING = "UTF-8";
}

PARSER_BEGIN(CCJSqlParser)

package net.sf.jsqlparser.parser;

import net.sf.jsqlparser.parser.feature.*;
import net.sf.jsqlparser.expression.*;
import net.sf.jsqlparser.expression.operators.arithmetic.*;
import net.sf.jsqlparser.expression.operators.conditional.*;
import net.sf.jsqlparser.expression.operators.relational.*;
import net.sf.jsqlparser.schema.*;
import net.sf.jsqlparser.statement.*;
import net.sf.jsqlparser.statement.analyze.*;
import net.sf.jsqlparser.statement.alter.*;
import net.sf.jsqlparser.statement.alter.sequence.*;
import net.sf.jsqlparser.statement.comment.*;
import net.sf.jsqlparser.statement.create.function.*;
import net.sf.jsqlparser.statement.create.index.*;
import net.sf.jsqlparser.statement.create.procedure.*;
import net.sf.jsqlparser.statement.create.schema.*;
import net.sf.jsqlparser.statement.create.synonym.*;
import net.sf.jsqlparser.statement.create.sequence.*;
import net.sf.jsqlparser.statement.create.table.*;
import net.sf.jsqlparser.statement.create.view.*;
import net.sf.jsqlparser.statement.delete.*;
import net.sf.jsqlparser.statement.drop.*;
import net.sf.jsqlparser.statement.insert.*;
import net.sf.jsqlparser.statement.replace.*;
import net.sf.jsqlparser.statement.execute.*;
import net.sf.jsqlparser.statement.select.*;
import net.sf.jsqlparser.statement.show.*;
import net.sf.jsqlparser.statement.truncate.*;
import net.sf.jsqlparser.statement.update.*;
import net.sf.jsqlparser.statement.upsert.*;
import net.sf.jsqlparser.statement.merge.*;
import net.sf.jsqlparser.statement.values.*;
import net.sf.jsqlparser.statement.grant.*;
import java.util.*;

/**
 * The parser generated by JavaCC
 */
public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
    public int bracketsCounter = 0;
    public int caseCounter = 0;
    public boolean interrupted = false;

    public CCJSqlParser withConfiguration(FeatureConfiguration configuration) {
        token_source.configuration = configuration;
        return this;
    }
    
    public FeatureConfiguration getConfiguration() {
        return token_source.configuration;
    }
    
    public CCJSqlParser me () {
    	return this;
    }

    private void linkAST(ASTNodeAccess access, SimpleNode node) {
        access.setASTNode(node);
        node.jjtSetValue(access);
    }

    public Node getASTRoot() {
        return jjtree.rootNode();
    }
}

PARSER_END(CCJSqlParser)

TOKEN_MGR_DECLS : {
    public FeatureConfiguration configuration = new FeatureConfiguration();

    public void CommonTokenAction(Token t)
	{
		t.absoluteBegin = getCurrentTokenAbsolutePosition();
		t.absoluteEnd = t.absoluteBegin + t.image.length();
	}

	public int getCurrentTokenAbsolutePosition()
	{
		if (input_stream instanceof SimpleCharStream)
			return ((SimpleCharStream)input_stream).getAbsoluteTokenBegin();
		return -1;
	}
}

SKIP:
{
    <WHITESPACE: " " | "\t" | "\r" | "\n">
}

TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */
{
    <K_ABSENT: "ABSENT">
|   <K_ACTION: "ACTION">
|   <K_ACTIVE: "ACTIVE">
|   <K_ADD:"ADD">
|   <K_ADVANCE:"ADVANCE">
|   <K_ADVISE:"ADVISE">
|   <K_AGAINST:"AGAINST">
|   <K_ALGORITHM: "ALGORITHM">
|   <K_ALL:"ALL">
|   <K_ALTER:"ALTER">
|   <K_ANALYZE:"ANALYZE">
|   <K_AND:"AND">
|   <K_AND_OPERATOR:"&&">
|   <K_ANY:"ANY">
|   <K_APPLY:"APPLY">
|   <K_ARCHIVE: "ARCHIVE">
|   <K_ARRAY_LITERAL: "ARRAY" >
|   <K_AS: "AS">
|   <K_AT: "AT">
|   <K_ASC:"ASC">
|   <K_AUTHORIZATION:"AUTHORIZATION">
|   <K_BEGIN:"BEGIN">
|   <K_BETWEEN:"BETWEEN">
|   <K_BINARY: "BINARY">
|   <K_BIT:"BIT">
|   <K_BOTH:"BOTH">
|   <K_BY:"BY">
|   <K_CACHE: "CACHE">
|   <K_BUFFERS: "BUFFERS">
|   <K_BYTE: "BYTE">
|   <K_CALL : "CALL">
|   <K_CASCADE: "CASCADE">
|   <K_CASE:"CASE">
|   <K_CASEWHEN:"CASEWHEN">  /* H2 casewhen function */
|   <K_CAST: "CAST">
|   <K_TRY_CAST: "TRY_CAST">
|   <K_CHARACTER:"CHARACTER">
|   <K_CHANGE:"CHANGE">
|   <K_CHANGES:"CHANGES">
|   <K_CHECK:"CHECK">
|   <K_CHECKPOINT:"CHECKPOINT">
|   <K_CHAR:"CHAR">
|   <K_CLOSE:"CLOSE">
|   <K_COLLATE:"COLLATE">
|   <K_COLUMN:"COLUMN">
|   <K_COLUMNS:"COLUMNS">
|   <K_COMMA: ",">
|   <K_COMMIT:"COMMIT">
|   <K_COMMENT:"COMMENT">
|   <K_CONFLICT:"CONFLICT">
|   <K_CONNECT:"CONNECT">
|   <K_CONNECT_BY_ROOT: "CONNECT_BY_ROOT"> 
|   <K_CONSTRAINT:"CONSTRAINT">
|   <K_COSTS: "COSTS">
|   <K_CREATE:"CREATE">
|   <K_CROSS:"CROSS">
|   <K_CURRENT: "CURRENT">
|   <K_CYCLE:"CYCLE">
|   <K_DATABASE:"DATABASE">
|   <K_DECLARE: "DECLARE">
|   <K_DATETIMELITERAL : ("DATE" | "TIME" | "TIMESTAMP") >
|   <K_DATE_LITERAL : ( "YEAR" | "MONTH" | "DAY" | "HOUR" | "MINUTE" | "SECOND" ) >
|   <K_DBA_RECYCLEBIN: "DBA_RECYCLEBIN">
|   <K_DEFAULT : "DEFAULT">
|   <K_DEFERRABLE : "DEFERRABLE">
|   <K_DELAYED : "DELAYED">
|   <K_DELETE:"DELETE">
|   <K_DESC:"DESC">
|   <K_DESCRIBE:"DESCRIBE">
|   <K_DISABLE : "DISABLE">
|   <K_DISCONNECT:"DISCONNECT">
|   <K_DISTINCT:"DISTINCT">
|   <K_DIV:"DIV">
|   <K_DDL:"DDL">
|   <K_DML:"DML">
|   <K_DO:"DO">
|   <K_DOUBLE : "DOUBLE">
|   <K_DROP:"DROP">
|   <K_DUMP:"DUMP">
|   <K_DUPLICATE: "DUPLICATE">
|   <K_ELSE:"ELSE">
|   <K_EMIT : "EMIT">
|   <K_ENABLE : "ENABLE">
|   <K_END:"END">
|   <K_ESCAPE:"ESCAPE">
|   <K_EXCEPT:"EXCEPT">
|   <K_EXCLUDE : "EXCLUDE">
|   <K_EXEC: "EXEC">
|   <K_EXECUTE: "EXECUTE">
|   <K_EXISTS:"EXISTS">
|   <K_EXPLAIN:"EXPLAIN">
|   <K_EXTENDED:"EXTENDED">
|   <K_EXTRACT:"EXTRACT">
|   <K_FETCH:"FETCH">
|   <K_ISOLATION:("UR" | "RS" | "RR" | "CS")>
|   <K_FILTER: "FILTER">
|   <K_FIRST: "FIRST">
|   <K_FALSE: "FALSE">
|   <K_FLUSH: "FLUSH">
|   <K_FOLLOWING: "FOLLOWING">
|   <K_FOR:"FOR">
|   <K_FORCE : "FORCE">
|   <K_FOREIGN:"FOREIGN">
|   <K_FORMAT:"FORMAT">
|   <K_FROM:"FROM">
|   <K_FULL:"FULL">
|   <K_FULLTEXT:"FULLTEXT">
|   <K_FUNCTION:"FUNCTION">
|   <K_GLOBAL:"GLOBAL">
|   <K_GRANT:"GRANT">
|   <K_GROUP:"GROUP">
|   <K_GROUPING:"GROUPING">
|   <K_GROUP_CONCAT:"GROUP_CONCAT">
|   <K_GUARD:"GUARD">
|   <K_HAVING:"HAVING">
|   <K_HIGH_PRIORITY : "HIGH_PRIORITY">
|   <K_HISTORY : "HISTORY">
|   <K_HOPPING:"HOPPING">
|   <K_IF:"IF">
|   <K_IIF:"IIF">
|   <K_IGNORE : "IGNORE">
|   <K_ILIKE:"ILIKE">
|   <K_IN:"IN">
|   <K_INCLUDE:"INCLUDE">
|   <K_INCREMENT:"INCREMENT">
|   <K_INDEX: "INDEX">
|   <K_INNER:"INNER">
|   <K_STRAIGHT:"STRAIGHT_JOIN">
|   <K_INSERT:"INSERT">
|   <K_INTERSECT:"INTERSECT">
|   <K_INTERVAL:"INTERVAL">
|   <K_INTO:"INTO">
|   <K_IS:"IS">
|   <K_ISNULL:"ISNULL">
|   <K_JOIN:"JOIN">
|   <K_JSON:"JSON">
|   <K_JSON_OBJECT: "JSON_OBJECT">
|   <K_JSON_OBJECTAGG: "JSON_OBJECTAGG">
|   <K_JSON_ARRAY: "JSON_ARRAY">
|   <K_JSON_ARRAYAGG: "JSON_ARRAYAGG">
|   <K_KEEP:"KEEP">
|   <K_KEY:"KEY">
|   <K_KEYS:"KEYS">
|   <K_FN:"FN">
|   <K_LAST: "LAST">
|   <K_LATERAL:"LATERAL">
|   <K_LEADING:"LEADING">
|   <K_LEFT:"LEFT">
|   <K_LIKE:"LIKE">
|   <K_LIMIT:"LIMIT">
|   <K_LOCAL:"LOCAL">
|   <K_LINK:"LINK">
|   <K_LOG:"LOG">
|   <K_LOW_PRIORITY : "LOW_PRIORITY">
|   <K_MATCH: "MATCH">
|   <K_MATCHED: "MATCHED">
|   <K_MATERIALIZED:"MATERIALIZED">
|   <K_MAXVALUE: "MAXVALUE">
|   <K_MERGE: "MERGE">
|   <K_MINUS:"MINUS">
|   <K_MINVALUE:"MINVALUE">
|   <K_MODIFY: "MODIFY">
|   <K_MOVEMENT: "MOVEMENT">

/* @todo:
   this collides with SELECT 'yelp'::name ...
|   <K_NAME:"NAME">
*/

|   <K_NATURAL:"NATURAL">
|   <K_NEXT:"NEXT">
|   <K_NEXTVAL: (  (("NEXTVAL")(" ")+("FOR"))  |  ( ("NEXT")(" ")+("VALUE") (" ")+("FOR") )  )>
|   <K_NO:"NO">
|   <K_NOCACHE:"NOCACHE">
|   <K_NOCYCLE:"NOCYCLE">
|   <K_NOKEEP:"NOKEEP">
|   <K_NOLOCK:"NOLOCK">
|   <K_NOMAXVALUE:"NOMAXVALUE">
|   <K_NOMINVALUE:"NOMINVALUE">
|   <K_NOORDER:"NOORDER">
|   <K_NOT:"NOT">
|   <K_NOTHING:"NOTHING">
|   <K_NOVALIDATE : "NOVALIDATE">
|   <K_NULL:"NULL">
|   <K_NULLS: "NULLS">
|   <K_NOWAIT: "NOWAIT">
|   <K_OF:"OF">
|   <K_OFF:"OFF">
|   <K_OFFSET:"OFFSET">
|   <K_ON:"ON">
|   <K_ONLY:"ONLY">
|   <K_OPEN:"OPEN">
|   <K_OR:"OR">
|   <K_ORACLE_NAMED_PARAMETER_ASSIGNMENT: "=>">
|   <K_ORDER:"ORDER">
|   <K_OUTER:"OUTER">
|   <K_OUTPUT:"OUTPUT">
|   <K_OVER:"OVER">
|   <K_OPTIMIZE: "OPTIMIZE" >
|   <K_PARALLEL:"PARALLEL">
|   <K_PARTITION:"PARTITION">
|   <K_PATH:"PATH">
|   <K_PERCENT:"PERCENT">
|   <K_PIVOT:"PIVOT">
|   <K_PLACING:"PLACING">
|   <K_PRECEDING: "PRECEDING">
|   <K_PRECISION : "PRECISION">
|   <K_PRIMARY:"PRIMARY">
|   <K_PRIOR:"PRIOR">
|   <K_PROCEDURE:"PROCEDURE">
|   <K_PUBLIC:"PUBLIC">
|   <K_PURGE:"PURGE">
|   <K_QUERY:"QUERY">
|   <K_QUICK : "QUICK">
|   <K_QUIESCE: "QUIESCE">
|   <K_RANGE: "RANGE">
|   <K_READ: "READ" >
|   <K_RECYCLEBIN: "RECYCLEBIN">
|   <K_RECURSIVE:"RECURSIVE">
|   <K_REFERENCES:"REFERENCES">
|   <K_REGEXP: "REGEXP">
|   <K_RLIKE: "RLIKE">
|   <K_REGISTER: "REGISTER">
|   <K_RENAME:"RENAME">
|   <K_REPLACE:"REPLACE">
|   <K_RESUMABLE: "RESUMABLE">
|   <K_RESUME: "RESUME">
|   <K_RESTRICT: "RESTRICT">
|   <K_RESTRICTED: "RESTRICTED">
|   <K_RETURNING: "RETURNING">
|   <K_RIGHT:"RIGHT">
|   <K_ROLLBACK:"ROLLBACK">
|   <K_ROW: "ROW">
|   <K_ROWS: "ROWS">
|   <K_SAVEPOINT: "SAVEPOINT">
|   <K_SCHEMA: "SCHEMA">
|   <K_SELECT: ("SELECT" | "SEL")>
|   <K_SEMI : "SEMI">
|   <K_SEQUENCE: "SEQUENCE">
|   <K_SEPARATOR:"SEPARATOR">
|   <K_SESSION:"SESSION">
|   <K_SET:"SET">
|   <K_RESET:"RESET">
|   <K_RESTART:"RESTART">
|   <K_SETS:"SETS">
|   <K_SHOW : "SHOW">
|   <K_SHUTDOWN : "SHUTDOWN">
|   <K_SIBLINGS:"SIBLINGS">
|   <K_SIMILAR:"SIMILAR">
|   <K_SIZE:"SIZE">
|   <K_SKIP: "SKIP">
|   <K_SOME:"SOME">
|   <K_START:"START">
|   <K_SUSPEND:"SUSPEND">
|   <K_SWITCH: "SWITCH">
|   <K_SYNONYM:"SYNONYM">
|   <K_SYSTEM:"SYSTEM">
|   <K_TABLE:"TABLE">
|   <K_TABLES:"TABLES">
|   <K_TABLESPACE : "TABLESPACE">
|   <K_THEN:"THEN">
|   <K_TEMP:"TEMP">
|   <K_TEMPORARY:"TEMPORARY">
|   <K_TIME_KEY_EXPR : ( 
                         ("CURRENT" ( "_" | (" ")+ ) "TIMESTAMP") 
                         | ("CURRENT" ( "_" | (" ")+ ) "TIME")
                         | ("CURRENT" ( "_" | (" ")+ ) "DATE")
                       ) ( "()" )?>
|   <K_TIMEOUT:"TIMEOUT">
|   <K_TO:"TO">
|   <K_TOP:"TOP">
|   <K_TRAILING:"TRAILING">
|   <K_TRUNCATE:"TRUNCATE">
|   <K_TRUE:"TRUE">
|   <K_TUMBLING:"TUMBLING">
|   <K_TYPE:"TYPE">
|   <K_UNBOUNDED: "UNBOUNDED">
|   <K_UNION:"UNION">
|   <K_UNIQUE:"UNIQUE">
|   <K_UNLOGGED: "UNLOGGED">
|   <K_UNPIVOT:"UNPIVOT">
|   <K_UPDATE:"UPDATE">
|   <K_UPSERT:"UPSERT">
|   <K_UNQIESCE:"UNQIESCE">
|   <K_USE:"USE">
|   <K_USER:"USER">
|   <K_SQL_CALC_FOUND_ROWS: "SQL_CALC_FOUND_ROWS">
|   <K_SQL_NO_CACHE: "SQL_NO_CACHE">
|   <K_SQL_CACHE: "SQL_CACHE">
|   <K_USING:"USING">
|   <K_SIGNED:"SIGNED">
|   <K_STRING_FUNCTION_NAME: ("SUBSTR" | "SUBSTRING" | "TRIM" | "POSITION" | "OVERLAY")>
|   <K_UNSIGNED:"UNSIGNED">
|   <K_VALIDATE : "VALIDATE">
|   <K_VALUE:"VALUE">
|   <K_VALUES:"VALUES">
|   <K_VARYING:"VARYING">
|   <K_VERBOSE: "VERBOSE">
|   <K_VIEW:"VIEW">
|   <K_WAIT : "WAIT">
|   <K_WHEN:"WHEN">
|   <K_WHERE:"WHERE">
|   <K_WINDOW:"WINDOW">
|   <K_WITH:"WITH">
|   <K_WITH_TIES:"WITH TIES">
|   <K_WITHIN:"WITHIN">
|   <K_WITHOUT:"WITHOUT">
|   <K_WORK:"WORK">
|   <K_XML:"XML">
|   <K_XOR:"XOR">
|   <K_XMLSERIALIZE:"XMLSERIALIZE">
|   <K_XMLAGG:"XMLAGG">
|   <K_XMLTEXT:"XMLTEXT">
|   <K_YAML:"YAML">
|   <K_ZONE:"ZONE">
}

TOKEN : /* Stuff */
{
    <ST_SEMICOLON : ";" >
}

TOKEN : /* Operators */
{
    <OP_GREATERTHANEQUALS: ">" (<WHITESPACE>)* "=">
|    <OP_MINORTHANEQUALS: "<" (<WHITESPACE>)* "=">
|    <OP_NOTEQUALSSTANDARD: "<" (<WHITESPACE>)* ">">
|    <OP_NOTEQUALSBANG: "!" (<WHITESPACE>)* "=">
|    <OP_CONCAT: "|" (<WHITESPACE>)* "|">
}

TOKEN : /* Date/Time with time zones */
{
    <DT_ZONE: <K_DATETIMELITERAL> (<WHITESPACE>)* ("(" <S_LONG> ")")? (<WHITESPACE>)* (<K_WITH> | <K_WITHOUT>) ((<WHITESPACE>)+ <K_LOCAL>)? (<WHITESPACE>)+ "TIME" (<WHITESPACE>)+ <K_ZONE>>
}

TOKEN : /* Numeric Constants */
{
   < S_DOUBLE: ((<S_LONG>)? "." <S_LONG> ( ["e","E"] (["+", "-"])? <S_LONG>)?
            |
            <S_LONG> "." (["e","E"] (["+", "-"])? <S_LONG>)?
            |
            <S_LONG> ["e","E"] (["+", "-"])? <S_LONG>
            )>
  |     < S_LONG: ( <DIGIT> )+ >
  |     < #DIGIT: ["0" - "9"] >
  |     < S_HEX: ("x'" ( <HEX_VALUE> )+ "'" | "0x" ( <HEX_VALUE> )+ ) >
  |     < #HEX_VALUE: ["0"-"9","A"-"F"]  >
}

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

TOKEN:
{
<S_IDENTIFIER: <LETTER> (<PART_LETTER>)*>
|   <#LETTER: ["$","A"-"Z","_","#","a"-"z","\u00a2"-"\u00a5","\u00aa","\u00b5","\u00ba","\u00c0"-"\u00d6","\u00d8"-"\u00f6","\u00f8"-"\u021f","\u0222"-"\u0233","\u0250"-"\u02ad","\u02b0"-"\u02b8","\u02bb"-"\u02c1","\u02d0"-"\u02d1","\u02e0"-"\u02e4","\u02ee","\u037a","\u0386","\u0388"-"\u038a","\u038c","\u038e"-"\u03a1","\u03a3"-"\u03ce","\u03d0"-"\u03d7","\u03da"-"\u03f3","\u0400"-"\u0481","\u048c"-"\u04c4","\u04c7"-"\u04c8","\u04cb"-"\u04cc","\u04d0"-"\u04f5","\u04f8"-"\u04f9","\u0531"-"\u0556","\u0559","\u0561"-"\u0587","\u05d0"-"\u05ea","\u05f0"-"\u05f2","\u0621"-"\u063a","\u0640"-"\u064a","\u0671"-"\u06d3","\u06d5","\u06e5"-"\u06e6","\u06fa"-"\u06fc","\u0710","\u0712"-"\u072c","\u0780"-"\u07a5","\u0905"-"\u0939","\u093d","\u0950","\u0958"-"\u0961","\u0985"-"\u098c","\u098f"-"\u0990","\u0993"-"\u09a8","\u09aa"-"\u09b0","\u09b2","\u09b6"-"\u09b9","\u09dc"-"\u09dd","\u09df"-"\u09e1","\u09f0"-"\u09f3","\u0a05"-"\u0a0a","\u0a0f"-"\u0a10","\u0a13"-"\u0a28","\u0a2a"-"\u0a30","\u0a32"-"\u0a33","\u0a35"-"\u0a36","\u0a38"-"\u0a39","\u0a59"-"\u0a5c","\u0a5e","\u0a72"-"\u0a74","\u0a85"-"\u0a8b","\u0a8d","\u0a8f"-"\u0a91","\u0a93"-"\u0aa8","\u0aaa"-"\u0ab0","\u0ab2"-"\u0ab3","\u0ab5"-"\u0ab9","\u0abd","\u0ad0","\u0ae0","\u0b05"-"\u0b0c","\u0b0f"-"\u0b10","\u0b13"-"\u0b28","\u0b2a"-"\u0b30","\u0b32"-"\u0b33","\u0b36"-"\u0b39","\u0b3d","\u0b5c"-"\u0b5d","\u0b5f"-"\u0b61","\u0b85"-"\u0b8a","\u0b8e"-"\u0b90","\u0b92"-"\u0b95","\u0b99"-"\u0b9a","\u0b9c","\u0b9e"-"\u0b9f","\u0ba3"-"\u0ba4","\u0ba8"-"\u0baa","\u0bae"-"\u0bb5","\u0bb7"-"\u0bb9","\u0c05"-"\u0c0c","\u0c0e"-"\u0c10","\u0c12"-"\u0c28","\u0c2a"-"\u0c33","\u0c35"-"\u0c39","\u0c60"-"\u0c61","\u0c85"-"\u0c8c","\u0c8e"-"\u0c90","\u0c92"-"\u0ca8","\u0caa"-"\u0cb3","\u0cb5"-"\u0cb9","\u0cde","\u0ce0"-"\u0ce1","\u0d05"-"\u0d0c","\u0d0e"-"\u0d10","\u0d12"-"\u0d28","\u0d2a"-"\u0d39","\u0d60"-"\u0d61","\u0d85"-"\u0d96","\u0d9a"-"\u0db1","\u0db3"-"\u0dbb","\u0dbd","\u0dc0"-"\u0dc6","\u0e01"-"\u0e30","\u0e32"-"\u0e33","\u0e3f"-"\u0e46","\u0e81"-"\u0e82","\u0e84","\u0e87"-"\u0e88","\u0e8a","\u0e8d","\u0e94"-"\u0e97","\u0e99"-"\u0e9f","\u0ea1"-"\u0ea3","\u0ea5","\u0ea7","\u0eaa"-"\u0eab","\u0ead"-"\u0eb0","\u0eb2"-"\u0eb3","\u0ebd","\u0ec0"-"\u0ec4","\u0ec6","\u0edc"-"\u0edd","\u0f00","\u0f40"-"\u0f47","\u0f49"-"\u0f6a","\u0f88"-"\u0f8b","\u1000"-"\u1021","\u1023"-"\u1027","\u1029"-"\u102a","\u1050"-"\u1055","\u10a0"-"\u10c5","\u10d0"-"\u10f6","\u1100"-"\u1159","\u115f"-"\u11a2","\u11a8"-"\u11f9","\u1200"-"\u1206","\u1208"-"\u1246","\u1248","\u124a"-"\u124d","\u1250"-"\u1256","\u1258","\u125a"-"\u125d","\u1260"-"\u1286","\u1288","\u128a"-"\u128d","\u1290"-"\u12ae","\u12b0","\u12b2"-"\u12b5","\u12b8"-"\u12be","\u12c0","\u12c2"-"\u12c5","\u12c8"-"\u12ce","\u12d0"-"\u12d6","\u12d8"-"\u12ee","\u12f0"-"\u130e","\u1310","\u1312"-"\u1315","\u1318"-"\u131e","\u1320"-"\u1346","\u1348"-"\u135a","\u13a0"-"\u13f4","\u1401"-"\u166c","\u166f"-"\u1676","\u1681"-"\u169a","\u16a0"-"\u16ea","\u1780"-"\u17b3","\u17db","\u1820"-"\u1877","\u1880"-"\u18a8","\u1e00"-"\u1e9b","\u1ea0"-"\u1ef9","\u1f00"-"\u1f15","\u1f18"-"\u1f1d","\u1f20"-"\u1f45","\u1f48"-"\u1f4d","\u1f50"-"\u1f57","\u1f59","\u1f5b","\u1f5d","\u1f5f"-"\u1f7d","\u1f80"-"\u1fb4","\u1fb6"-"\u1fbc","\u1fbe","\u1fc2"-"\u1fc4","\u1fc6"-"\u1fcc","\u1fd0"-"\u1fd3","\u1fd6"-"\u1fdb","\u1fe0"-"\u1fec","\u1ff2"-"\u1ff4","\u1ff6"-"\u1ffc","\u203f"-"\u2040","\u207f","\u20a0"-"\u20af","\u2102","\u2107","\u210a"-"\u2113","\u2115","\u2119"-"\u211d","\u2124","\u2126","\u2128","\u212a"-"\u212d","\u212f"-"\u2131","\u2133"-"\u2139","\u2160"-"\u2183","\u3005"-"\u3007","\u3021"-"\u3029","\u3031"-"\u3035","\u3038"-"\u303a","\u3041"-"\u3094","\u309d"-"\u309e","\u30a1"-"\u30fe","\u3105"-"\u312c","\u3131"-"\u318e","\u31a0"-"\u31b7","\u3400"-"\u4db5","\u4e00"-"\u9fa5","\ua000"-"\ua48c","\uac00"-"\ud7a3","\uf900"-"\ufa2d","\ufb00"-"\ufb06","\ufb13"-"\ufb17","\ufb1d","\ufb1f"-"\ufb28","\ufb2a"-"\ufb36","\ufb38"-"\ufb3c","\ufb3e","\ufb40"-"\ufb41","\ufb43"-"\ufb44","\ufb46"-"\ufbb1","\ufbd3"-"\ufd3d","\ufd50"-"\ufd8f","\ufd92"-"\ufdc7","\ufdf0"-"\ufdfb","\ufe33"-"\ufe34","\ufe4d"-"\ufe4f","\ufe69","\ufe70"-"\ufe72","\ufe74","\ufe76"-"\ufefc","\uff04","\uff21"-"\uff3a","\uff3f","\uff41"-"\uff5a","\uff65"-"\uffbe","\uffc2"-"\uffc7","\uffca"-"\uffcf","\uffd2"-"\uffd7","\uffda"-"\uffdc","\uffe0"-"\uffe1","\uffe5"-"\uffe6"]>
|   <#PART_LETTER: ["\u0000"-"\b","\u000e"-"\u001b","$","#","@","0"-"9","A"-"Z","_","a"-"z","\u007f"-"\u009f","\u00a2"-"\u00a5","\u00aa","\u00b5","\u00ba","\u00c0"-"\u00d6","\u00d8"-"\u00f6","\u00f8"-"\u021f","\u0222"-"\u0233","\u0250"-"\u02ad","\u02b0"-"\u02b8","\u02bb"-"\u02c1","\u02d0"-"\u02d1","\u02e0"-"\u02e4","\u02ee","\u0300"-"\u034e","\u0360"-"\u0362","\u037a","\u0386","\u0388"-"\u038a","\u038c","\u038e"-"\u03a1","\u03a3"-"\u03ce","\u03d0"-"\u03d7","\u03da"-"\u03f3","\u0400"-"\u0481","\u0483"-"\u0486","\u048c"-"\u04c4","\u04c7"-"\u04c8","\u04cb"-"\u04cc","\u04d0"-"\u04f5","\u04f8"-"\u04f9","\u0531"-"\u0556","\u0559","\u0561"-"\u0587","\u0591"-"\u05a1","\u05a3"-"\u05b9","\u05bb"-"\u05bd","\u05bf","\u05c1"-"\u05c2","\u05c4","\u05d0"-"\u05ea","\u05f0"-"\u05f2","\u0621"-"\u063a","\u0640"-"\u0655","\u0660"-"\u0669","\u0670"-"\u06d3","\u06d5"-"\u06dc","\u06df"-"\u06e8","\u06ea"-"\u06ed","\u06f0"-"\u06fc","\u070f"-"\u072c","\u0730"-"\u074a","\u0780"-"\u07b0","\u0901"-"\u0903","\u0905"-"\u0939","\u093c"-"\u094d","\u0950"-"\u0954","\u0958"-"\u0963","\u0966"-"\u096f","\u0981"-"\u0983","\u0985"-"\u098c","\u098f"-"\u0990","\u0993"-"\u09a8","\u09aa"-"\u09b0","\u09b2","\u09b6"-"\u09b9","\u09bc","\u09be"-"\u09c4","\u09c7"-"\u09c8","\u09cb"-"\u09cd","\u09d7","\u09dc"-"\u09dd","\u09df"-"\u09e3","\u09e6"-"\u09f3","\u0a02","\u0a05"-"\u0a0a","\u0a0f"-"\u0a10","\u0a13"-"\u0a28","\u0a2a"-"\u0a30","\u0a32"-"\u0a33","\u0a35"-"\u0a36","\u0a38"-"\u0a39","\u0a3c","\u0a3e"-"\u0a42","\u0a47"-"\u0a48","\u0a4b"-"\u0a4d","\u0a59"-"\u0a5c","\u0a5e","\u0a66"-"\u0a74","\u0a81"-"\u0a83","\u0a85"-"\u0a8b","\u0a8d","\u0a8f"-"\u0a91","\u0a93"-"\u0aa8","\u0aaa"-"\u0ab0","\u0ab2"-"\u0ab3","\u0ab5"-"\u0ab9","\u0abc"-"\u0ac5","\u0ac7"-"\u0ac9","\u0acb"-"\u0acd","\u0ad0","\u0ae0","\u0ae6"-"\u0aef","\u0b01"-"\u0b03","\u0b05"-"\u0b0c","\u0b0f"-"\u0b10","\u0b13"-"\u0b28","\u0b2a"-"\u0b30","\u0b32"-"\u0b33","\u0b36"-"\u0b39","\u0b3c"-"\u0b43","\u0b47"-"\u0b48","\u0b4b"-"\u0b4d","\u0b56"-"\u0b57","\u0b5c"-"\u0b5d","\u0b5f"-"\u0b61","\u0b66"-"\u0b6f","\u0b82"-"\u0b83","\u0b85"-"\u0b8a","\u0b8e"-"\u0b90","\u0b92"-"\u0b95","\u0b99"-"\u0b9a","\u0b9c","\u0b9e"-"\u0b9f","\u0ba3"-"\u0ba4","\u0ba8"-"\u0baa","\u0bae"-"\u0bb5","\u0bb7"-"\u0bb9","\u0bbe"-"\u0bc2","\u0bc6"-"\u0bc8","\u0bca"-"\u0bcd","\u0bd7","\u0be7"-"\u0bef","\u0c01"-"\u0c03","\u0c05"-"\u0c0c","\u0c0e"-"\u0c10","\u0c12"-"\u0c28","\u0c2a"-"\u0c33","\u0c35"-"\u0c39","\u0c3e"-"\u0c44","\u0c46"-"\u0c48","\u0c4a"-"\u0c4d","\u0c55"-"\u0c56","\u0c60"-"\u0c61","\u0c66"-"\u0c6f","\u0c82"-"\u0c83","\u0c85"-"\u0c8c","\u0c8e"-"\u0c90","\u0c92"-"\u0ca8","\u0caa"-"\u0cb3","\u0cb5"-"\u0cb9","\u0cbe"-"\u0cc4","\u0cc6"-"\u0cc8","\u0cca"-"\u0ccd","\u0cd5"-"\u0cd6","\u0cde","\u0ce0"-"\u0ce1","\u0ce6"-"\u0cef","\u0d02"-"\u0d03","\u0d05"-"\u0d0c","\u0d0e"-"\u0d10","\u0d12"-"\u0d28","\u0d2a"-"\u0d39","\u0d3e"-"\u0d43","\u0d46"-"\u0d48","\u0d4a"-"\u0d4d","\u0d57","\u0d60"-"\u0d61","\u0d66"-"\u0d6f","\u0d82"-"\u0d83","\u0d85"-"\u0d96","\u0d9a"-"\u0db1","\u0db3"-"\u0dbb","\u0dbd","\u0dc0"-"\u0dc6","\u0dca","\u0dcf"-"\u0dd4","\u0dd6","\u0dd8"-"\u0ddf","\u0df2"-"\u0df3","\u0e01"-"\u0e3a","\u0e3f"-"\u0e4e","\u0e50"-"\u0e59","\u0e81"-"\u0e82","\u0e84","\u0e87"-"\u0e88","\u0e8a","\u0e8d","\u0e94"-"\u0e97","\u0e99"-"\u0e9f","\u0ea1"-"\u0ea3","\u0ea5","\u0ea7","\u0eaa"-"\u0eab","\u0ead"-"\u0eb9","\u0ebb"-"\u0ebd","\u0ec0"-"\u0ec4","\u0ec6","\u0ec8"-"\u0ecd","\u0ed0"-"\u0ed9","\u0edc"-"\u0edd","\u0f00","\u0f18"-"\u0f19","\u0f20"-"\u0f29","\u0f35","\u0f37","\u0f39","\u0f3e"-"\u0f47","\u0f49"-"\u0f6a","\u0f71"-"\u0f84","\u0f86"-"\u0f8b","\u0f90"-"\u0f97","\u0f99"-"\u0fbc","\u0fc6","\u1000"-"\u1021","\u1023"-"\u1027","\u1029"-"\u102a","\u102c"-"\u1032","\u1036"-"\u1039","\u1040"-"\u1049","\u1050"-"\u1059","\u10a0"-"\u10c5","\u10d0"-"\u10f6","\u1100"-"\u1159","\u115f"-"\u11a2","\u11a8"-"\u11f9","\u1200"-"\u1206","\u1208"-"\u1246","\u1248","\u124a"-"\u124d","\u1250"-"\u1256","\u1258","\u125a"-"\u125d","\u1260"-"\u1286","\u1288","\u128a"-"\u128d","\u1290"-"\u12ae","\u12b0","\u12b2"-"\u12b5","\u12b8"-"\u12be","\u12c0","\u12c2"-"\u12c5","\u12c8"-"\u12ce","\u12d0"-"\u12d6","\u12d8"-"\u12ee","\u12f0"-"\u130e","\u1310","\u1312"-"\u1315","\u1318"-"\u131e","\u1320"-"\u1346","\u1348"-"\u135a","\u1369"-"\u1371","\u13a0"-"\u13f4","\u1401"-"\u166c","\u166f"-"\u1676","\u1681"-"\u169a","\u16a0"-"\u16ea","\u1780"-"\u17d3","\u17db","\u17e0"-"\u17e9","\u180b"-"\u180e","\u1810"-"\u1819","\u1820"-"\u1877","\u1880"-"\u18a9","\u1e00"-"\u1e9b","\u1ea0"-"\u1ef9","\u1f00"-"\u1f15","\u1f18"-"\u1f1d","\u1f20"-"\u1f45","\u1f48"-"\u1f4d","\u1f50"-"\u1f57","\u1f59","\u1f5b","\u1f5d","\u1f5f"-"\u1f7d","\u1f80"-"\u1fb4","\u1fb6"-"\u1fbc","\u1fbe","\u1fc2"-"\u1fc4","\u1fc6"-"\u1fcc","\u1fd0"-"\u1fd3","\u1fd6"-"\u1fdb","\u1fe0"-"\u1fec","\u1ff2"-"\u1ff4","\u1ff6"-"\u1ffc","\u200c"-"\u200f","\u202a"-"\u202e","\u203f"-"\u2040","\u206a"-"\u206f","\u207f","\u20a0"-"\u20af","\u20d0"-"\u20dc","\u20e1","\u2102","\u2107","\u210a"-"\u2113","\u2115","\u2119"-"\u211d","\u2124","\u2126","\u2128","\u212a"-"\u212d","\u212f"-"\u2131","\u2133"-"\u2139","\u2160"-"\u2183","\u3005"-"\u3007","\u3021"-"\u302f","\u3031"-"\u3035","\u3038"-"\u303a","\u3041"-"\u3094","\u3099"-"\u309a","\u309d"-"\u309e","\u30a1"-"\u30fe","\u3105"-"\u312c","\u3131"-"\u318e","\u31a0"-"\u31b7","\u3400"-"\u4db5","\u4e00"-"\u9fa5","\ua000"-"\ua48c","\uac00"-"\ud7a3","\uf900"-"\ufa2d","\ufb00"-"\ufb06","\ufb13"-"\ufb17","\ufb1d"-"\ufb28","\ufb2a"-"\ufb36","\ufb38"-"\ufb3c","\ufb3e","\ufb40"-"\ufb41","\ufb43"-"\ufb44","\ufb46"-"\ufbb1","\ufbd3"-"\ufd3d","\ufd50"-"\ufd8f","\ufd92"-"\ufdc7","\ufdf0"-"\ufdfb","\ufe20"-"\ufe23","\ufe33"-"\ufe34","\ufe4d"-"\ufe4f","\ufe69","\ufe70"-"\ufe72","\ufe74","\ufe76"-"\ufefc","\ufeff","\uff04","\uff10"-"\uff19","\uff21"-"\uff3a","\uff3f","\uff41"-"\uff5a","\uff65"-"\uffbe","\uffc2"-"\uffc7","\uffca"-"\uffcf","\uffd2"-"\uffd7","\uffda"-"\uffdc","\uffe0"-"\uffe1","\uffe5"-"\uffe6","\ufff9"-"\ufffb"]>
|   < S_CHAR_LITERAL: (["U","E","N","R","B"]|"RB"|"_utf8")? (("'" ( <ESC> | ~["'", "\\", "\n", "\r"] )* "'") | ("'" ("''" | ~["'"])* "'")) >
|   < S_QUOTED_IDENTIFIER: "\"" (~["\n","\r","\""])* "\"" | "$$" (~["\n","\r","\""])* "$$" | ("`" (~["\n","\r","`"])+ "`") | ( "[" (~["\n","\r","]"])* "]" ) >
    { if ( !configuration.getAsBoolean(Feature.allowSquareBracketQuotation) && matchedToken.image.charAt(0) == '[' ) {
         matchedToken.image = "[";
         for (int i=0;i<CCJSqlParserConstants.tokenImage.length;i++) {
            if (CCJSqlParserConstants.tokenImage[i].equals("\"[\"")) {
                matchedToken.kind = i;
            }
         }
         input_stream.backup(image.length() - 1);
       }
    }
|   < #ESC: "\\" ["n","t","b","r","f","\\","'","\""] >
}

Statement Statement() #Statement:
{   
    IfElseStatement ifElseStatement = null;
    Statement stm = null;
    Statement stm2 = null;
    Expression condition;
}
{
    try {
        (
            <K_IF> condition=Condition() 
            stm = SingleStatement() {  ifElseStatement = new IfElseStatement(condition, stm); }
            [ <ST_SEMICOLON> { ifElseStatement.setUsingSemicolonForIfStatement(true); } ]
            [ LOOKAHEAD(2) 
                <K_ELSE> stm2 = SingleStatement() {  ifElseStatement.setElseStatement(stm2);  }
                [ <ST_SEMICOLON> { ifElseStatement.setUsingSemicolonForElseStatement(true); }]
            ]
            <EOF>
        )
        |
        (
            stm = SingleStatement()
            [ <ST_SEMICOLON> ]
            <EOF>
        )
        |
        LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) stm = UnsupportedStatement()
    } catch (ParseException e) {
        if (errorRecovery) {
            parseErrors.add(e);
            error_skipto(ST_SEMICOLON);
        }
        else
            throw e;
    }

	{
		return ifElseStatement!=null ? ifElseStatement : stm;
	}
}

Statement SingleStatement() :
{ 
    Statement stm = null;
    List<WithItem> with = null;
}
{
    try {
        (
            LOOKAHEAD(2) (
                "(" with=WithList()
                (
                    stm = Select( with ) { ( (Select) stm).setUsingWithBrackets(true); }

                    /* @todo: unsure, if we need to implement those
                              since DMLs in brackets do not really make any sense
                    |
                    stm = Insert( with ) { ( (Insert) stm).setUsingWithBrackets(true); }
                    |
                    stm = Update( with ) { ( (Update) stm).setUsingWithBrackets(true); }
                    |
                    stm = Delete( with ) { ( (Delete) stm).setUsingWithBrackets(true); }
                    |
                    stm = Merge( with ) { ( (Merge) stm).setUsingWithBrackets(true); }

                     */
                )
                ")"
            )
            |
            (
                [ with=WithList() ]
                (
                    stm = Select( with )
                    |
                    stm = Insert( with )
                    |
                    stm = Update( with )
                    |
                    stm = Delete( with )
                    |
                    stm = Merge( with)
                )
            )
            |
            stm = Upsert()
            |
            LOOKAHEAD(3)
            stm = Replace()
            |
            LOOKAHEAD(2)
            stm = AlterTable()
            |
            LOOKAHEAD(2)
            stm = AlterSession()
            |
            LOOKAHEAD(CreateFunctionStatement())
            stm = CreateFunctionStatement()
            |
            LOOKAHEAD(CreateIndex())
            stm = CreateIndex()
            |
            LOOKAHEAD(CreateSchema())
            stm = CreateSchema()
            |
            LOOKAHEAD(CreateSequence())
            stm = CreateSequence()
            |
            LOOKAHEAD(CreateSynonym())
            stm = CreateSynonym()
            |
            LOOKAHEAD(CreateTable())
            stm = CreateTable()
            |
            LOOKAHEAD(CreateView())
            stm = CreateView()
            |
            LOOKAHEAD(AlterView())
            stm = AlterView()
            |
            LOOKAHEAD(AlterSequence())
            stm = AlterSequence()
            |
            stm = Drop()
            |
            stm = Analyze()
            |
            stm = Truncate()
            |
            stm = Execute()
            |
            stm = Set()
            |
            stm = RenameTableStatement()
            |
            stm = Reset()
            |
            LOOKAHEAD(ShowColumns())
            stm = ShowColumns()
            |
            LOOKAHEAD(ShowTables())
            stm = ShowTables()
            |
            stm = Show()
            |
            stm = Use()
            |
            stm = SavepointStatement()
            |
            stm = RollbackStatement()
            |
            stm = Commit()
            |
            stm = Comment()
            |
            stm = Describe()
            |
            stm = Explain()
            |
            stm = Declare()
            |
            stm = Grant()
            |
            stm = PurgeStatement()
            |
            stm = AlterSystemStatement()
        )
        { return stm; }
    } catch (ParseException e) {
        if (errorRecovery) {
            parseErrors.add(e);
            error_skipto(ST_SEMICOLON);
            return null;
        } else
            throw e;
    }
}

Block Block() #Block : {
    Statements stmts = new Statements();
    List<Statement> list = new ArrayList<Statement>();
    Statement stm;
    Block block = new Block();
}
{
    <K_BEGIN>
    (<ST_SEMICOLON>)*
    try {
       (
           (
                stm = SingleStatement()
                | stm = Block()
           )
           <ST_SEMICOLON>
           { list.add(stm); }
       )

        (
             (
                (
                    stm = SingleStatement()
                    | stm = Block()
                )
                <ST_SEMICOLON>
                { list.add(stm); }
            )
       )*
    } catch (ParseException e) {
        if (errorRecovery) {
            parseErrors.add(e);
            error_skipto(ST_SEMICOLON);
        } else {
            throw e;
        }           
    }

    {
        stmts.setStatements(list);
        block.setStatements(stmts);
    }

    <K_END> [LOOKAHEAD(2) <ST_SEMICOLON>]
    {
        return block;
    }
}

Statements Statements() #Statements : {
    Statements stmts = new Statements();
    List<Statement> list = new ArrayList<Statement>();
    
    IfElseStatement ifElseStatement = null;
    Statement stm = null;
    Statement stm2 = null;
    Expression condition;
}
{
    (<ST_SEMICOLON>)*
    try {
        (
            (
                 <K_IF> condition=Condition() 
                 stm = SingleStatement() {  ifElseStatement = new IfElseStatement(condition, stm); }
                 [ LOOKAHEAD(2) 
                     [ <ST_SEMICOLON> { ifElseStatement.setUsingSemicolonForIfStatement(true); } ]
                     <K_ELSE> stm2 = SingleStatement() {  ifElseStatement.setElseStatement(stm2);  } 
                 ]

                 { list.add( ifElseStatement ); }
            )
            |
            (
                 stm = SingleStatement() 
                 | stm = Block()

                 [ LOOKAHEAD(2)  <ST_SEMICOLON> ]
            ) { list.add(stm); }
            |
            LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) stm = UnsupportedStatement()
            { if ( !((UnsupportedStatement) stm).isEmpty() ) list.add(stm); }
        )

        (
            <ST_SEMICOLON> { if (stm2!=null)
                                ifElseStatement.setUsingSemicolonForElseStatement(true);
                             else if (ifElseStatement!=null)
                                ifElseStatement.setUsingSemicolonForIfStatement(true); }
            [
                (
                    <K_IF> condition=Condition()
                    stm = SingleStatement() {  ifElseStatement = new IfElseStatement(condition, stm); }
                    [ LOOKAHEAD(2)
                        [ <ST_SEMICOLON> { ifElseStatement.setUsingSemicolonForIfStatement(true); } ]
                        <K_ELSE> stm2 = SingleStatement() {  ifElseStatement.setElseStatement(stm2);  }
                    ]

                    { list.add( ifElseStatement ); }
               )
               |
               (
                    stm = SingleStatement()
                    | stm = Block()

                    [ LOOKAHEAD(2)  <ST_SEMICOLON> ]
               ) { list.add(stm); }
               |
               // For any reason, we can't LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) here
               // As it will result in a Stack Overflow
               stm = UnsupportedStatement()
               { if ( !((UnsupportedStatement) stm).isEmpty() ) list.add(stm); }
            ]
        )*
        <EOF>
    } catch (ParseException e) {
        if (errorRecovery) {
            parseErrors.add(e);
            error_skipto(ST_SEMICOLON);
        } else {
            throw e;
        }
    }
    {
        return stmts.withStatements(list);
    }
}

JAVACODE
void error_skipto(int kind) {
  ParseException e = generateParseException();
  Token t;
  do {
    t = getNextToken();
  } while (t.kind != kind && t.kind != EOF);
}

DeclareStatement Declare(): {
    UserVariable userVariable;
    ColDataType colDataType;
    Expression defaultExpr = null;
    DeclareStatement stmt = new DeclareStatement();
    String typeName;
    String columnName;
    ColumnDefinition colDef;
} {
    <K_DECLARE> userVariable = UserVariable()
    (
            ( <K_TABLE> "(" colDef = ColumnDefinition()
      {
        stmt.withUserVariable(userVariable)
        .withDeclareType(DeclareType.TABLE)
        .addColumnDefinition(colDef);
      }
                        ("," colDef = ColumnDefinition() { stmt.addColumnDefinition(colDef); })*  ")"
            )
        |
            <K_AS> typeName = RelObjectName()
                {
                    stmt.withUserVariable(userVariable)
                      .withDeclareType(DeclareType.AS)
                      .withTypeName(typeName);
                }
        |
            (colDataType = ColDataType() ["=" defaultExpr = Expression()]
                {
                  stmt.withDeclareType(DeclareType.TYPE)
                  .addType(userVariable, colDataType, defaultExpr);
                }
                ("," userVariable = UserVariable() colDataType = ColDataType() { defaultExpr = null; }
                ["=" defaultExpr = Expression()] { stmt.addType(userVariable, colDataType, defaultExpr); } )*
            )
    )
    {
       return stmt;
    }
}



SetStatement Set(): {
    String name;
    ArrayList<Expression> expList;
    boolean useEqual = false;
    SetStatement set;
    Expression exp = null;
    Token tk = null;
    String effectParameter = null;
}
{
    <K_SET>
    (

        [LOOKAHEAD(3) (tk = <K_LOCAL> | tk = <K_SESSION>) {effectParameter = tk.image; } ]
        ( LOOKAHEAD(2)
          <K_DATETIMELITERAL> <K_ZONE> { name = "Time Zone"; useEqual=false; }
        | (name = RelObjectNameExt() ["=" { useEqual=true; } ])
        )
    )
    exp=SimpleExpression()
    {expList = new ArrayList<Expression>(); expList.add(exp); }

    { set = new SetStatement(name,expList).withUseEqual(useEqual).withEffectParameter(effectParameter); }
    (
        { useEqual=false; }
        ","
        (LOOKAHEAD(3)
            (
              ( LOOKAHEAD(2)
                  <K_DATETIMELITERAL> <K_ZONE> { name = "Time Zone"; useEqual=false; }
                | (name = RelObjectNameExt() ["=" { useEqual=true; } ])
              )
              exp=SimpleExpression()
              {expList = new ArrayList<Expression>();
                expList.add(exp);
                set.add(name, expList, useEqual);}
            )
            | exp=SimpleExpression() { expList.add(exp); }
         ))*
    { return set; }
}

ResetStatement Reset(): {
    String name;
    ResetStatement reset;
    Token all;
}
{
    <K_RESET> ( LOOKAHEAD(2) <K_DATETIMELITERAL> <K_ZONE> {name = "Time Zone"; } | name = RelObjectName() | all = <K_ALL> {name = all.image; } )
    { reset = new ResetStatement(name); }
    { return reset; }
}

RenameTableStatement RenameTableStatement(): {
    RenameTableStatement renameTableStatement;
    Table oldName;
    Table newName;
    boolean usingTableKeyword=false;
    boolean usesIfExistsKeyword=false;
    String waitDirective = "";
    Token token;
}
{
    <K_RENAME> 
    [ LOOKAHEAD(2) <K_TABLE> { usingTableKeyword = true; } ]
    [ LOOKAHEAD(2) <K_IF> <K_EXISTS> { usesIfExistsKeyword = true; } ]
    oldName = Table()
    [ ( 
        <K_WAIT> token=<S_LONG> { waitDirective = "WAIT " + token.image; }
        |
        <K_NOWAIT>  { waitDirective = "NOWAIT"; }
       ) ]
    <K_TO>
    newName = Table()

    { 
        renameTableStatement = new RenameTableStatement(oldName, newName, usingTableKeyword, usesIfExistsKeyword, waitDirective); 
    }

    (
        ","
        oldName = Table()
        <K_TO>
        newName = Table()
        {
            renameTableStatement.addTableNames(oldName, newName);
        }
    )*

    { 
        return renameTableStatement;
    }
}

PurgeStatement PurgeStatement(): {
    PurgeStatement purgeStatement = null;
    Table table;
    Index index;
    Token tableSpaceToken;
    Token userToken = null;
}
{
    <K_PURGE> 
    (
        <K_TABLE> table=Table() { purgeStatement = new PurgeStatement(table); }
        | 
        <K_INDEX> index=Index() { purgeStatement = new PurgeStatement(index); }
        |
        <K_RECYCLEBIN> { purgeStatement = new PurgeStatement(PurgeObjectType.RECYCLEBIN); }
        |
        <K_DBA_RECYCLEBIN> { purgeStatement = new PurgeStatement(PurgeObjectType.DBA_RECYCLEBIN); }
        |
        <K_TABLESPACE> tableSpaceToken=<S_IDENTIFIER> [ <K_USER> userToken=<S_IDENTIFIER> ] { 
            purgeStatement = new PurgeStatement(
                PurgeObjectType.TABLESPACE
                , tableSpaceToken.image
                , userToken!=null ? userToken.image : null); 
            }
    )

    {
        return purgeStatement;
    }
}

DescribeStatement Describe(): {
    Table table;
} {
    <K_DESCRIBE> table = Table()
    {
        return new DescribeStatement(table);
    }
}

ExplainStatement Explain(): {
    Select select;
    List<ExplainStatement.Option> options = null;
} {
    <K_EXPLAIN>
    options=ExplainStatementOptions()
    select = SelectWithWithItems( )
    {
       ExplainStatement es = new ExplainStatement(select);
       if(options != null && !options.isEmpty()) {
         for(ExplainStatement.Option o : options) {
           es.addOption(o);
         }
       }
       return es;
    }
}

/**
 * Postgres supports TRUE,ON,1,FALSE,OFF,0 as values
 */
String ExplainOptionBoolean():
{
  Token tk = null;
}
{
   // intentionally not supporting 0,1 at the moment
   [( tk=<K_TRUE> | tk=<K_FALSE> | tk=<K_ON> | tk=<K_OFF> )] // optional
   {
    return tk != null ? tk.image : null;
   }
}

/**
 * The output format, which can be TEXT, XML, JSON, or YAML
 */
String ExplainFormatOption():
{
  Token tk = null;
}
{
   // TODO support Text
   [( tk=<K_XML> | tk=<K_JSON> | tk=<K_YAML> )] // optional
   {
    return tk != null ? tk.image : null;
   }
}

/**
 * Options for explain, see https://www.postgresql.org/docs/9.1/sql-explain.html
 */
List<ExplainStatement.Option> ExplainStatementOptions():
{
  List<ExplainStatement.Option> options = new ArrayList<ExplainStatement.Option>();
  ExplainStatement.Option option = null;
  Token token = null;
  String value = null;
}
{
  (
    (<K_ANALYZE> value=ExplainOptionBoolean()
     {
       option = new ExplainStatement.Option(ExplainStatement.OptionType.ANALYZE);
       option.setValue(value);
       options.add(option);
     }
    )
    |
    (<K_BUFFERS> value=ExplainOptionBoolean()
      {
        option = new ExplainStatement.Option(ExplainStatement.OptionType.BUFFERS);
        option.setValue(value);
        options.add(option);
      }
    )
    |
    (<K_COSTS> value=ExplainOptionBoolean()
      {
        option = new ExplainStatement.Option(ExplainStatement.OptionType.COSTS);
        option.setValue(value);
        options.add(option);
      }
    )
    |
    (<K_VERBOSE> value=ExplainOptionBoolean()
      {
        option = new ExplainStatement.Option(ExplainStatement.OptionType.VERBOSE);
        option.setValue(value);
        options.add(option);
      }
    )
    |
    (<K_FORMAT> value=ExplainFormatOption()
      {
        option = new ExplainStatement.Option(ExplainStatement.OptionType.FORMAT);
        option.setValue(value);
        options.add(option);
      }
    )
  )* //zero or many times those productions
  {
    return options;
  }
}

UseStatement Use(): {
    String name;
    boolean hasSchemaKeyword = false;
}
{
    <K_USE> [ LOOKAHEAD(2) <K_SCHEMA> { hasSchemaKeyword = true; } ] name = RelObjectNameExt()
    {
        return new UseStatement(name, hasSchemaKeyword);
    }
}

ShowColumnsStatement ShowColumns(): {
    String tableName;
}
{
    <K_SHOW> <K_COLUMNS> <K_FROM> tableName = RelObjectNameExt()
    {
        return new ShowColumnsStatement(tableName);
    }
}

// https://dev.mysql.com/doc/refman/8.0/en/show-tables.html
ShowTablesStatement ShowTables(): {
    ShowTablesStatement showTablesStatement;
    EnumSet<ShowTablesStatement.Modifiers> modifiers =  EnumSet.noneOf(ShowTablesStatement.Modifiers.class);
    ShowTablesStatement.SelectionMode selectionMode = null;
    String dbName = null;
    Expression likeExpression = null;
    Expression whereCondition = null;
}
{
  <K_SHOW>
  [ <K_EXTENDED> { modifiers.add(ShowTablesStatement.Modifiers.EXTENDED); } ]
  [ <K_FULL> { modifiers.add(ShowTablesStatement.Modifiers.FULL); } ]
  <K_TABLES>
  [
    (
      <K_FROM> {selectionMode = ShowTablesStatement.SelectionMode.FROM; }
    | <K_IN> { selectionMode = ShowTablesStatement.SelectionMode.IN; }
    )
    dbName = RelObjectNameExt()
  ]
  [ (<K_LIKE> likeExpression = SimpleExpression() | <K_WHERE> whereCondition = Expression()) ]
  {
    showTablesStatement = new ShowTablesStatement();
    showTablesStatement.setModifiers(modifiers);
    showTablesStatement.setSelectionMode(selectionMode);
    showTablesStatement.setDbName(dbName);
    showTablesStatement.setLikeExpression(likeExpression);
    showTablesStatement.setWhereCondition(whereCondition);
    return showTablesStatement;
  }
}

ShowStatement Show(): {
    String name;
}
{
    <K_SHOW> name = RelObjectNameExt()
    {
        return new ShowStatement(name);
    }
}

ValuesStatement Values(): {
    ItemsList itemsList;
} {
    ( <K_VALUES> | <K_VALUE> )

    itemsList = SimpleExpressionList(false)

    {
        return new ValuesStatement(itemsList);
    }
}

Update Update( List<WithItem> with ):
{
    Update update = new Update();
    Table table = null;
    List<Join> startJoins = null;

    UpdateSet updateSet = null;
    Column tableColumn = null;
    SubSelect subSelect;
    Expression valueExpression = null;
    ExpressionList expressionList;
    Expression where = null;
    FromItem fromItem = null;
    List<Join> joins = null;
    Limit limit = null;
    List<OrderByElement> orderByElements;
    boolean useColumnsBrackets = false;
    List<SelectItem> returning = null;
    Token tk = null;
    UpdateModifierPriority modifierPriority = null;
    boolean modifierIgnore = false;

    OutputClause outputClause = null;
}
{
   <K_UPDATE> { update.setOracleHint(getOracleHint()); }
    [<K_LOW_PRIORITY> { modifierPriority = UpdateModifierPriority.LOW_PRIORITY; }]
    [<K_IGNORE> { modifierIgnore = true; }]
    table=TableWithAlias() startJoins=JoinsList()
    <K_SET>
    (
        LOOKAHEAD(3) tableColumn=Column() "=" valueExpression=SimpleExpression() { update.addUpdateSet(tableColumn, valueExpression); }
                     ("," tableColumn=Column() "=" valueExpression=SimpleExpression() { update.addUpdateSet(tableColumn, valueExpression); } )*
        |
        (
            { updateSet = new UpdateSet(); update.addUpdateSet(updateSet); }

            [ LOOKAHEAD(2) "(" { updateSet.setUsingBracketsForColumns(true); } ]
            tableColumn=Column() { updateSet.add(tableColumn); }
            ( LOOKAHEAD(2) "," tableColumn=Column() { updateSet.add(tableColumn); } )*
            [ LOOKAHEAD(2) ")" ]

            "="

            (
                LOOKAHEAD(3) subSelect=SubSelect() { updateSet.add(subSelect.withUseBrackets(false)); }
                |
                LOOKAHEAD(3) "(" expressionList = ComplexExpressionList() { updateSet.setUsingBracketsForValues(true); updateSet.add(expressionList); } ")"
                |
                valueExpression = Expression() { updateSet.add(valueExpression); }
            )

            (
                ","  { updateSet = new UpdateSet(); update.addUpdateSet(updateSet); }

                [ LOOKAHEAD(2) "(" { updateSet.setUsingBracketsForColumns(true); } ]
                tableColumn=Column() { updateSet.add(tableColumn); }
                ( LOOKAHEAD(2) "," tableColumn=Column() { updateSet.add(tableColumn); } )*
                [ LOOKAHEAD(2) ")" ]

                "="

                (
                    LOOKAHEAD(3) subSelect=SubSelect() { updateSet.add(subSelect.withUseBrackets(false)); }
                    |
                    LOOKAHEAD(3) "(" expressionList = ComplexExpressionList() { updateSet.setUsingBracketsForValues(true); updateSet.add(expressionList); } ")"
                    |
                    valueExpression = Expression() { updateSet.add(valueExpression); }
                )
            ) *
        )
    )

    [ outputClause = OutputClause() {update.setOutputClause(outputClause); } ]

    [ <K_FROM>
      fromItem=FromItem()
      joins=JoinsList() ]

    [ where=WhereClause() { update.setWhere(where); } ]

    [ orderByElements = OrderByElements() { update.setOrderByElements(orderByElements); } ]
    [ limit = PlainLimit() { update.setLimit(limit); } ]
    [ <K_RETURNING> returning=SelectItemsList() ]

    {
        return update.withWithItemsList(with)
              .withTable(table)
              .withStartJoins(startJoins)
              .withFromItem(fromItem)
              .withJoins(joins)
              .withModifierPriority(modifierPriority)
              .withModifierIgnore(modifierIgnore)
              .withReturningExpressionList(returning);
    }
}

Replace Replace():
{
    Replace replace = new Replace();
    Table table = null;
    Column tableColumn = null;
    Expression value = null;

    List<Column> columns = new ArrayList<Column>();
    List<Expression> expList = new ArrayList<Expression>();
    MultiExpressionList multiExpr = null;
    ItemsList itemsList = null;
    Expression exp = null;
}
{
    ( <K_REPLACE> [LOOKAHEAD(2) <K_INTO> { replace.setUseIntoTables(true); }] table=Table() )

    (
        (
            <K_SET> tableColumn=Column() "=" value=SimpleExpression() { columns.add(tableColumn); expList.add(value); }
              ("," tableColumn=Column() "=" value=SimpleExpression() { columns.add(tableColumn); expList.add(value); } )*
             {
                   replace.setExpressions(expList);
             }
        )
        |

        (
             [LOOKAHEAD(2) "(" tableColumn=Column() { columns.add(tableColumn); } ("," tableColumn=Column() { columns.add(tableColumn); } )* ")"  ]
            (
                LOOKAHEAD(2) [<K_VALUES> | <K_VALUE>] "(" exp=PrimaryExpression() { expList.add(exp); }
                        ("," exp=PrimaryExpression()  { expList.add(exp); } )* ")" { itemsList = new ExpressionList(expList); }
                        ("," "(" exp=SimpleExpression() {
                            if (multiExpr==null) {
                                multiExpr=new MultiExpressionList();
                                multiExpr.addExpressionList((ExpressionList)itemsList);
                                itemsList = multiExpr;
                            }
                            expList = new ArrayList<Expression>();
                            expList.add(exp); }
                            ("," exp=SimpleExpression() { expList.add(exp); } )* ")" { multiExpr.addExpressionList(expList); } )*
                |
                    { replace.setUseValues(false); }
                    itemsList=SubSelect()
                    { ((SubSelect)itemsList).setUseBrackets(false); }
            )
            {
                replace.setItemsList(itemsList);
            }
        )
    )
   {
        if (!columns.isEmpty()) {
           replace.withColumns(columns);
        } 
        return replace.withTable(table);
   }
}

List<SelectExpressionItem> ListExpressionItem():
{
   List<SelectExpressionItem> retval = new ArrayList<SelectExpressionItem>();
   SelectExpressionItem item;
}
{
   item = SelectExpressionItem() {retval.add(item);}
   (<K_COMMA> item = SelectExpressionItem() {retval.add(item);} )*
   { return retval; }
}

Insert Insert( List<WithItem> with ):
{
    Insert insert = new Insert();
    Table table = null;
    Column tableColumn = null;
    List<Column> columns = new ArrayList<Column>();
    Expression exp = null;
    List<SelectItem> returning = null;
    Select select = null;
    boolean useDuplicate = false;
    List<Column> duplicateUpdateColumns = null;
    List<Expression> duplicateUpdateExpressionList = null;
    Token tk = null;
    InsertModifierPriority modifierPriority = null;
    boolean modifierIgnore = false;
    boolean useSet = false;
    List<Column> setColumns = new ArrayList<Column>();
    List<Expression> setExpressionList = new ArrayList<Expression>();
    String name = null;
    boolean useAs = false;
    OutputClause outputClause = null;

    UpdateSet updateSet = null;
    InsertConflictTarget conflictTarget = null;
    InsertConflictAction conflictAction = null;
}
{    
    <K_INSERT> { insert.setOracleHint(getOracleHint()); }
    [(tk = <K_LOW_PRIORITY> | tk = <K_DELAYED> | tk = <K_HIGH_PRIORITY>)
    {if (tk!=null)
        modifierPriority = InsertModifierPriority.valueOf(tk.image.toUpperCase());
    }]
    [<K_IGNORE>{ modifierIgnore = true; }]
    [<K_INTO>] table=Table()

    [ [<K_AS> { useAs = true; } ] name=RelObjectNameWithoutValue() { table.setAlias(new Alias(name,useAs)); }]

    [LOOKAHEAD(2) "(" tableColumn=Column() { columns.add(tableColumn); } ("," tableColumn=Column() { columns.add(tableColumn); } )* ")"  ]

    [ outputClause = OutputClause() { insert.setOutputClause(outputClause); } ]

    (
        (
            <K_SET> { useSet = true; }
            tableColumn=Column() "=" exp=SimpleExpression()
            {
                setColumns = new ArrayList<Column>();
                setExpressionList = new ArrayList<Expression>();
                setColumns.add(tableColumn);
                setExpressionList.add(exp);
            }
            ("," tableColumn=Column() "=" exp=SimpleExpression()
                { setColumns.add(tableColumn);
                setExpressionList.add(exp); } )*
        )
        |
        select = SelectWithWithItems( )
    )

    [ LOOKAHEAD(2) <K_ON> <K_DUPLICATE> <K_KEY> <K_UPDATE>
        { useDuplicate = true; }
      tableColumn=Column() "=" exp=SimpleExpression()
        {
            duplicateUpdateColumns = new ArrayList<Column>();
            duplicateUpdateExpressionList = new ArrayList<Expression>();
            duplicateUpdateColumns.add(tableColumn);
            duplicateUpdateExpressionList.add(exp);
        }
      ("," tableColumn=Column() "=" exp=SimpleExpression()
        { duplicateUpdateColumns.add(tableColumn);
        duplicateUpdateExpressionList.add(exp); } )*]

    [
        <K_ON> <K_CONFLICT>
        [ conflictTarget = InsertConflictTarget() ]
        conflictAction = InsertConflictAction() { insert.withConflictTarget(conflictTarget).setConflictAction(conflictAction); }
    ]

    [ <K_RETURNING> returning=SelectItemsList() ]

    {
        if (!columns.isEmpty()) { 
            insert.setColumns(columns);
        }
        return insert.withWithItemsList(with)
              .withSelect(select)
              .withTable(table)
              .withUseDuplicate(useDuplicate)
              .withDuplicateUpdateColumns(duplicateUpdateColumns)
              .withDuplicateUpdateExpressionList(duplicateUpdateExpressionList)
              .withReturningExpressionList(returning)
              .withModifierPriority(modifierPriority)
              .withModifierIgnore(modifierIgnore)
              .withUseSet(useSet)
              .withUseSetColumns(setColumns)
              .withSetExpressionList(setExpressionList);
    }
}

InsertConflictTarget  InsertConflictTarget():
{
    String indexColumnName = null;
    Expression indexExpression = null;
    Expression whereExpression = null;
    String constraintName = null ;
}
{
    (
        (
           "("
            indexColumnName = RelObjectNameExt2()
//            |
//            (
//                "(" indexExpression = Expression() ")"
//            )

            ")"
            [ whereExpression = WhereClause() ]
        )
        |
        (
         <K_ON> <K_CONSTRAINT> constraintName = RelObjectNameExt2()
        )
    )

    { return new InsertConflictTarget(indexColumnName, indexExpression, whereExpression, constraintName); }
}

InsertConflictAction InsertConflictAction():
{
    InsertConflictAction conflictAction;
    ArrayList<UpdateSet> updateSets = new ArrayList<UpdateSet>();
    UpdateSet updateSet = null;
    Expression whereExpression = null;

    Column tableColumn = null;
    SubSelect subSelect;
    Expression valueExpression = null;
    ExpressionList expressionList;
}
{
    (
        LOOKAHEAD(2) (
            <K_DO> <K_NOTHING> { conflictAction = new InsertConflictAction( ConflictActionType.DO_NOTHING ); }
        )
        |
        (
            <K_DO> <K_UPDATE> <K_SET> { conflictAction = new InsertConflictAction( ConflictActionType.DO_UPDATE ); }
            (
                LOOKAHEAD(3) tableColumn=Column()
                               "=" valueExpression=SimpleExpression() {
                                                                        updateSet = new UpdateSet();
                                                                        updateSet.add(tableColumn);
                                                                        updateSet.add(valueExpression);
                                                                        updateSets.add(updateSet);
                                                                        }
                             (
                                ","
                                tableColumn=Column()
                                "=" valueExpression=SimpleExpression() {
                                                                        updateSet = new UpdateSet();
                                                                        updateSet.add(tableColumn);
                                                                        updateSet.add(valueExpression);
                                                                        updateSets.add(updateSet);
                                                                        }
                            )*
                |
                (
                    { updateSet = new UpdateSet(); updateSets.add(updateSet); }

                    [ LOOKAHEAD(2) "(" { updateSet.setUsingBracketsForColumns(true); } ]
                    tableColumn=Column() { updateSet.add(tableColumn); }
                    ( LOOKAHEAD(2) "," tableColumn=Column() { updateSet.add(tableColumn); } )*
                    [ LOOKAHEAD(2) ")" ]

                    "="

                    (
                        LOOKAHEAD(3) subSelect=SubSelect() { updateSet.add(subSelect.withUseBrackets(false)); }
                        |
                        LOOKAHEAD(3) "(" expressionList = ComplexExpressionList() { updateSet.setUsingBracketsForValues(true); updateSet.add(expressionList); } ")"
                        |
                        valueExpression = Expression() { updateSet.add(valueExpression); }
                    )

                    (
                        ","  { updateSet = new UpdateSet(); updateSets.add(updateSet); }

                        [ LOOKAHEAD(2) "(" { updateSet.setUsingBracketsForColumns(true); } ]
                        tableColumn=Column() { updateSet.add(tableColumn); }
                        ( LOOKAHEAD(2) "," tableColumn=Column() { updateSet.add(tableColumn); } )*
                        [ LOOKAHEAD(2) ")" ]

                        "="

                        (
                            LOOKAHEAD(3) subSelect=SubSelect() { updateSet.add(subSelect.withUseBrackets(false)); }
                            |
                            LOOKAHEAD(3) "(" expressionList = ComplexExpressionList() { updateSet.setUsingBracketsForValues(true); updateSet.add(expressionList); } ")"
                            |
                            valueExpression = Expression() { updateSet.add(valueExpression); }
                        )
                    ) *
                )
            )

            [ whereExpression = WhereClause() ]
        )
    )

    { return conflictAction
                .withUpdateSets(updateSets)
                .withWhereExpression(whereExpression); }
}

OutputClause OutputClause():
{
    List<SelectItem> selectItemList = null;
    UserVariable tableVariable = null;
    Table outputTable = null;
    List<String> columnList = null;
}
{
    <K_OUTPUT>
    selectItemList = SelectItemsList()
    [   <K_INTO>
        (
            tableVariable = UserVariable()
            |
            outputTable = Table()
        )
        [
           LOOKAHEAD(2)  columnList = ColumnsNamesList()
        ]
    ]

    {
        return new OutputClause(selectItemList, tableVariable, outputTable, columnList);
    }
}

Upsert Upsert():
{
    Upsert upsert = new Upsert();
    Table table = null;
    Column tableColumn = null;
    List<Column> columns = new ArrayList<Column>();
    List<Expression> primaryExpList = new ArrayList<Expression>();
    ItemsList itemsList = null;
    Expression exp = null;
    MultiExpressionList multiExpr = null;
    List<SelectExpressionItem> returning = null;
    Select select = null;
    boolean useSelectBrackets = false;
    boolean useDuplicate = false;
    List<Column> duplicateUpdateColumns = null;
    List<Expression> duplicateUpdateExpressionList = null;
    Token tk = null;
}
{
    <K_UPSERT>
    [<K_INTO>] table=Table()


     [LOOKAHEAD(2) "(" tableColumn=Column() { columns.add(tableColumn); } ("," tableColumn=Column() { columns.add(tableColumn); } )* ")"  ]
    (
        LOOKAHEAD(2) [<K_VALUES> | <K_VALUE>]  "(" exp=SimpleExpression() { primaryExpList.add(exp); }
                ("," exp=SimpleExpression()  { primaryExpList.add(exp); } )* ")" { itemsList = new ExpressionList(primaryExpList); }
            ("," "(" exp=SimpleExpression() {
                    if (multiExpr==null) {
                        multiExpr=new MultiExpressionList();
                        multiExpr.addExpressionList((ExpressionList)itemsList);
                        itemsList = multiExpr;
                    }
                    primaryExpList = new ArrayList<Expression>();
                    primaryExpList.add(exp); }
                ("," exp=SimpleExpression() { primaryExpList.add(exp); } )* ")" { multiExpr.addExpressionList(primaryExpList); } )*

        |

        (
            LOOKAHEAD(2) "(" { useSelectBrackets = true; }
                { upsert.setUseValues(false); }
                select = SelectWithWithItems( )
            ")"
            |
            { upsert.setUseValues(false); }
            select = SelectWithWithItems( )
        )
    )

    [ <K_ON> <K_DUPLICATE> <K_KEY> <K_UPDATE>
        { useDuplicate = true; }
      tableColumn=Column() "=" exp=SimpleExpression()
        {
            duplicateUpdateColumns = new ArrayList<Column>();
            duplicateUpdateExpressionList = new ArrayList<Expression>();
            duplicateUpdateColumns.add(tableColumn);
            duplicateUpdateExpressionList.add(exp);
        }
      ("," tableColumn=Column() "=" exp=SimpleExpression()
        { duplicateUpdateColumns.add(tableColumn);
        duplicateUpdateExpressionList.add(exp); } )*]

    {
		if (columns.size() > 0) {
            upsert.setColumns(columns);
        }
        return upsert.withItemsList(itemsList)
              .withUseSelectBrackets(useSelectBrackets)
              .withSelect(select)
              .withTable(table)
              .withUseDuplicate(useDuplicate)
              .withDuplicateUpdateColumns(duplicateUpdateColumns)
              .withDuplicateUpdateExpressionList(duplicateUpdateExpressionList);
    }
}

Delete Delete( List<WithItem> with ):
{
    Delete delete = new Delete();
    Table table = null;
    List<Table> tables = new ArrayList<Table>();
    Table usingTable = null;
    List<Table> usingList = new ArrayList<Table>();
    List<Join> joins = null;
    Expression where = null;
    Limit limit = null;
    List<OrderByElement> orderByElements;
    boolean hasFrom = false;
    Token tk = null;
    DeleteModifierPriority modifierPriority = null;
    boolean modifierIgnore = false;
    boolean modifierQuick = false;

    List<SelectItem> returning = null;
    OutputClause outputClause = null;
}
{
    <K_DELETE> { delete.setOracleHint(getOracleHint()); }
    [<K_LOW_PRIORITY> { modifierPriority = DeleteModifierPriority.LOW_PRIORITY; }]
    [<K_QUICK> { modifierQuick = true; }]
    [<K_IGNORE> { modifierIgnore = true; }]
    [LOOKAHEAD(4) (table=TableWithAlias() { tables.add(table); }
          ("," table=TableWithAlias() { tables.add(table); } )*
    [ outputClause = OutputClause() {delete.setOutputClause(outputClause); } ]
    <K_FROM> | <K_FROM>) { hasFrom = true; }]

    [ LOOKAHEAD(3) table=TableWithAlias()  joins=JoinsList() ]
    [ <K_USING> usingTable=TableWithAlias() { usingList.add(usingTable); }
          ("," usingTable=TableWithAlias() { usingList.add(usingTable); } )*]
    [where=WhereClause() { delete.setWhere(where); } ]
    [orderByElements = OrderByElements() { delete.setOrderByElements(orderByElements); } ]
    [limit=PlainLimit() {delete.setLimit(limit); } ]

    [  <K_RETURNING> returning=SelectItemsList() ]
    {
        if (joins != null && joins.size() > 0) {
            delete.setJoins(joins);
        }
        return delete.withWithItemsList(with)
              .withTables(tables)
              .withTable(table)
              .withHasFrom(hasFrom)
              .withUsingList(usingList)
              .withModifierPriority(modifierPriority)
              .withModifierIgnore(modifierIgnore)
              .withModifierQuick(modifierQuick)
              .withReturningExpressionList(returning);
    }
}

Statement Merge( List<WithItem> with ) : {
    Merge merge = new Merge();
    Table table;
    SubSelect select;
    Alias alias;
    Expression condition;
    MergeUpdate update;
    MergeInsert insert;
}
{
    <K_MERGE> { merge.setOracleHint(getOracleHint()); } <K_INTO> table=TableWithAlias() { merge.setTable(table); }
    <K_USING>
        ( table=Table() { merge.setUsingTable(table); }
            | "(" select=SubSelect() { merge.setUsingSelect(select); } ")" )
     [ alias = Alias() { merge.setUsingAlias(alias); } ] <K_ON>
       "(" condition = Expression() { merge.setOnCondition(condition); } ")"

    [
        ( LOOKAHEAD(2) update = MergeUpdateClause() { merge.setMergeUpdate(update); }
          [ insert = MergeInsertClause() { merge.setMergeInsert(insert); } ]
        | insert = MergeInsertClause() { merge.withMergeInsert(insert).withInsertFirst(true); }
          [ update = MergeUpdateClause() { merge.setMergeUpdate(update); } ]
        )
    ]


    /*[ LOOKAHEAD(2) update = MergeUpdateClause() { merge.setMergeUpdate(update); } ]

    [ insert = MergeInsertClause() { merge.setMergeInsert(insert); } ]*/

    { return merge.withWithItemsList(with); }
}

MergeUpdate MergeUpdateClause() : {
    MergeUpdate mu = new MergeUpdate();
    List<Column> columns = new ArrayList<Column>();
    List<Expression> expList = new ArrayList<Expression>();
    Column col;
    Expression exp;
    Expression condition;
}
{
  <K_WHEN> <K_MATCHED> <K_THEN>  <K_UPDATE>
    <K_SET>
     col = Column() "=" exp = SimpleExpression()
            { columns.add(col); expList.add(exp); }
        ("," col = Column() "=" exp = SimpleExpression() { columns.add(col); expList.add(exp); } )*

        { mu.withColumns(columns).withValues(expList); }

        [ <K_WHERE> condition = Expression() { mu.setWhereCondition(condition); }]
        [ <K_DELETE> <K_WHERE> condition = Expression() { mu.setDeleteWhereCondition(condition); } ]

        { return mu; }
}

MergeInsert MergeInsertClause() : {
    MergeInsert mi = new MergeInsert();
    List<Column> columns = new ArrayList<Column>();
    List<Expression> expList = new ArrayList<Expression>();
    Column col;
    Expression exp;
    Expression condition;
}
{
    <K_WHEN> <K_NOT> <K_MATCHED> <K_THEN>
        <K_INSERT> ["(" col=Column() { columns.add(col); } ("," col=Column() { columns.add(col); } )* ")"]  <K_VALUES>
           "(" exp=SimpleExpression() { expList.add(exp); } ("," exp=SimpleExpression() { expList.add(exp); } )* ")"

        { mi.withColumns(columns).withValues(expList); }
        
        [ <K_WHERE> condition = Expression() { mi.setWhereCondition(condition); }]
        
        { return mi; }
}

List<String> RelObjectNameList() : {
    String token = null;
    List<String> data = new ArrayList<String>();
} {
    token = RelObjectNameExt() { data.add(token); }
    ( LOOKAHEAD (2) ("." | ":") ("." { data.add(null); })* token = RelObjectNameExt2() { data.add(token); } ) *

    { return data; }
}

// See: http://technet.microsoft.com/en-us/library/ms187879%28v=sql.105%29.aspx

Column Column() #Column :
{
    List<String> data = new ArrayList<String>();
}
{
    data = RelObjectNameList()

    {
        Column col = new Column(data);
        linkAST(col,jjtThis);
        return col;
    }
}

/*
Not all names should be allowed for aliases.
*/
String RelObjectNameWithoutValue() :
{    Token tk = null; }
{
    (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER> 
      | tk=<K_ALGORITHM> | tk=<K_AT>
      | tk=<K_BYTE> | tk=<K_CHAR> | tk=<K_CHANGE> | tk=<K_CHARACTER>
      | tk=<K_CAST> | tk =<K_TRY_CAST> | tk=<K_COMMENT> | tk=<K_COSTS> | tk=<K_DISABLE> | tk=<K_DESC>
      | tk=<K_DO> | tk=<K_DEFAULT> | tk=<K_EXTRACT> | tk=<K_FILTER> | tk=<K_FIRST> | tk=<K_FOLLOWING> | tk=<K_JSON>
      | tk=<K_LAST> | tk=<K_LEADING> | tk=<K_MATERIALIZED> | tk=<K_NULLS> | tk=<K_PARTITION> | tk=<K_RANGE>
      | tk=<K_ROW> | tk=<K_ROWS> | tk=<K_SIBLINGS> | tk=<K_XML>
      | tk=<K_COLUMN> | tk=<K_REPLACE> | tk=<K_TRUNCATE> | tk=<K_KEY>
      | tk=<K_OPEN> | tk=<K_OVER> | tk=<K_PERCENT> | tk=<K_PRIOR>
      | tk=<K_SEPARATOR> | tk=<K_NO> | tk=<K_ACTION> | tk=<K_CASCADE> | tk=<K_END>
      | tk=<K_TABLE> | tk=<K_DATETIMELITERAL> | tk=<K_COMMIT> | tk=<K_PRECISION>
      | tk=<K_INSERT> | tk=<K_INDEX> | tk=<K_PRIMARY> | tk=<K_ENABLE>
      | tk=<K_TEMP> | tk=<K_TEMPORARY> | tk=<K_TO> | tk=<K_TYPE> | tk=<K_ISNULL>
	  | tk=<K_ZONE> | tk=<K_COLUMNS> | tk=<K_DESCRIBE> | tk=<K_FN> | tk=<K_PATH>
      | tk=<K_DATE_LITERAL> | tk=<K_NEXTVAL> | tk=<K_TRUE> | tk=<K_FALSE> | tk=<K_DUPLICATE>
      | tk=<K_READ> | tk=<K_SCHEMA> | tk=<K_SIGNED> | tk=<K_SIZE> | tk=<K_SEQUENCE> | tk=<K_SESSION> | tk=<K_SKIP>
      | tk=<K_SYNONYM>
      | tk=<K_VIEW> | tk=<K_NOLOCK> | tk=<K_VALIDATE> | tk=<K_CYCLE> | tk=<K_OF> | tk=<K_EXCLUDE>
    /*| tk=<K_PLACING> | tk=<K_BOTH> | tk=<K_LEADING> | tk=<K_TRAILING> */
      | tk=<K_FORMAT> | tk=<K_DIV> | tk=<K_UNSIGNED> | tk=<K_CASE> | tk=<K_LOCAL>
      | tk=<K_ARRAY_LITERAL>
      | tk=<K_STRING_FUNCTION_NAME>
      | tk=<K_USER>
      | tk=<K_RECYCLEBIN> | tk=<K_DBA_RECYCLEBIN> | tk=<K_ISOLATION>

      /* Keywords for ALTER SESSION */
      /* | tk=<K_NAME> */ | tk=<K_TIMEOUT> | tk=<K_PARALLEL>

      | tk=<K_LINK>
      /* Keywords for ALTER SYSTEM */
      | tk=<K_LOG> | tk=<K_DUMP> | tk=<K_FLUSH> | tk=<K_ACTIVE> | tk=<K_RESUME> | tk=<K_SWITCH> | tk=<K_SUSPEND>
      | tk=<K_ARCHIVE> | tk=<K_QUIESCE> | tk=<K_HISTORY> | tk=<K_SHUTDOWN> | tk=<K_REGISTER> | tk=<K_UNQIESCE>
      | tk=<K_RESTRICTED> | tk=<K_CHECKPOINT> | tk=<K_DISCONNECT>
      | tk=<K_SYSTEM>
      | tk=<K_QUERY>
      | tk=<K_FULLTEXT>
      | tk=<K_TABLESPACE>

      | tk=<K_KEEP>
      )

    { return tk.image; }
}

/*
Normal names.
*/
String RelObjectName() :
{    Token tk = null; String result = null; }
{
    (result = RelObjectNameWithoutValue()
		| tk=<K_GROUP> | tk=<K_INTERVAL> | tk=<K_ON> | tk=<K_ORDER> | tk=<K_START> | tk=<K_TOP> | tk=<K_VALUE>
        | tk=<K_VALUES> | tk=<K_CREATE> | tk=<K_TABLES> )

    {
		if (tk!=null) result=tk.image;
		return result;
	}
}

String RelObjectNameWithoutStart() :
{    Token tk = null; String result = null; }
{
    (result = RelObjectNameWithoutValue() | tk=<K_TOP> | tk=<K_VALUE> | tk=<K_VALUES>
        | tk=<K_INTERVAL> )

    {
		if (tk!=null) result=tk.image;
		return result;
	}
}

/*
Extended version of object names.
*/
String RelObjectNameExt():
{ Token tk = null;
  String result=null;
}
{
    ( result=RelObjectName() | tk=<K_ALL> | tk=<K_ANY>  | tk=<K_SOME> | tk=<K_LEFT> | tk=<K_RIGHT> | tk=<K_SET>
        | tk=<K_DOUBLE> | tk=<K_IF> | tk=<K_IIF> | tk=<K_OPTIMIZE> | tk=<K_LIMIT>
        | tk=<K_OFFSET> | tk=<K_PROCEDURE> | tk=<K_PUBLIC> 
        | tk=<K_CASEWHEN> | tk=<K_IN> | tk=<K_GROUPING>  )
    {
        if (tk!=null) result=tk.image;
        return result;
    }
}

/*
Extended usage of object names - part 2. Using within multipart names as following parts.
*/
String RelObjectNameExt2():
{ Token tk = null;
  String result=null;
}
{
    ( result=RelObjectNameExt() | tk=<K_FROM> | tk=<K_SELECT> | tk=<K_CURRENT> )
    {
        if (tk!=null) result=tk.image;
        return result;
    }
}

Table Table() #Table :
{
    //String serverName = null, databaseName = null, schemaName = null, tableName = null;
    List<String> data = new ArrayList<String>();
}
{
    data = RelObjectNameList()

    {
        Table table = new Table(data);
		linkAST(table,jjtThis);
        return table;
    }
}

Table TableWithAlias():
{
    Table table = null;
    Alias alias = null;
}
{
    table=Table() [alias=Alias() { table.setAlias(alias); }]
    { return table; }
}

Select SelectWithWithItems( ):
{
    Select select;
    List<WithItem> with = null;
}
{
    (LOOKAHEAD(2) (  "(" with=WithList()  select = Select( with ) ")" { select.withUsingWithBrackets(true); }   )
    |
    (  [with=WithList()] select = Select( with )  ))
    {
            return select;
    }
}

Select Select( List<WithItem> with ):
{
    Select select = new Select();
    SelectBody selectBody = null;
}
{
    selectBody = SelectBody()
    {
        return select.withWithItemsList(with).withSelectBody(selectBody);
    }
}

SelectBody SelectBody():
{ SelectBody selectBody = null; }
{
    selectBody = SetOperationList()
    { return selectBody; }
}

PlainSelect PlainSelect() #PlainSelect:
{
    PlainSelect plainSelect = new PlainSelect();
    List<SelectItem> selectItems = null;
    FromItem fromItem = null;
    List<Join> joins = null;
    List<SelectItem> distinctOn = null;
    Expression where = null;
    List<OrderByElement> orderByElements;
    GroupByElement groupBy = null;
    Expression having = null;
    Limit limit = null;
    Offset offset = null;
    Fetch fetch = null;
    WithIsolation withIsolation = null;
    OptimizeFor optimize = null;
    Top top = null;
        Skip skip = null;
        First first = null;
    OracleHierarchicalExpression oracleHierarchicalQueryClause = null;
    List<Table> intoTables = null;
    Table updateTable = null;
    Wait wait = null;
    boolean mySqlSqlCalcFoundRows = false;
    Token token;
    KSQLWindow ksqlWindow = null;
    boolean noWait = false;
    String windowName = null;
    WindowDefinition winDef;
}
{
    <K_SELECT>

    [ <K_STRAIGHT> { plainSelect.setMySqlHintStraightJoin(true); } ]

    { plainSelect.setOracleHint(getOracleHint()); }

    [ LOOKAHEAD(2) skip = Skip() { plainSelect.setSkip(skip);    } ]

    [ LOOKAHEAD(2) first = First() { plainSelect.setFirst(first); } ]

    [ LOOKAHEAD(2)
        ( <K_ALL>
        |
            (
                <K_DISTINCT> { Distinct distinct = new Distinct(); plainSelect.setDistinct(distinct); }
                    [ LOOKAHEAD(2) "ON" "(" distinctOn=SelectItemsList()  { plainSelect.getDistinct().setOnSelectItems(distinctOn); } ")" ]
            )
        |
            (
                <K_UNIQUE> { Distinct distinct = new Distinct(true); plainSelect.setDistinct(distinct); }
            )
        |
            (
                <K_SQL_CALC_FOUND_ROWS> { plainSelect.setMySqlSqlCalcFoundRows(true); }
            )
        |
            (
                <K_SQL_NO_CACHE> { plainSelect.setMySqlSqlCacheFlag(MySqlSqlCacheFlags.SQL_NO_CACHE); }
                | <K_SQL_CACHE> { plainSelect.setMySqlSqlCacheFlag(MySqlSqlCacheFlags.SQL_CACHE); }
            )
        )
    ]

    [ LOOKAHEAD(2) top = Top() { plainSelect.setTop(top);    } ]

    selectItems=SelectItemsList()

    [intoTables = IntoClause() { plainSelect.setIntoTables(intoTables); } ]
    [ LOOKAHEAD(2) <K_FROM>
      fromItem=FromItem()
      joins=JoinsList() ]

    [ LOOKAHEAD(2) ksqlWindow=KSQLWindowClause() { plainSelect.setKsqlWindow(ksqlWindow); } ]
    [ LOOKAHEAD(2) where=WhereClause() { plainSelect.setWhere(where); }]
    [ oracleHierarchicalQueryClause=OracleHierarchicalQueryClause() { plainSelect.setOracleHierarchical(oracleHierarchicalQueryClause); } ]
    [ groupBy=GroupByColumnReferences() { plainSelect.setGroupByElement(groupBy); }]
    [ having=Having() { plainSelect.setHaving(having); }]
    [LOOKAHEAD(<K_ORDER> <K_SIBLINGS> <K_BY>) orderByElements = OrderByElements() { plainSelect.setOracleSiblings(true); plainSelect.setOrderByElements(orderByElements);    }   ]
    [ <K_WINDOW> 
        windowName = RelObjectName() <K_AS> winDef = windowDefinition() { List<WindowDefinition> winDefs = new ArrayList<WindowDefinition>(); winDefs.add(winDef.withWindowName(windowName)); }
        ( LOOKAHEAD(2) "," windowName = RelObjectName() <K_AS> winDef = windowDefinition() { winDefs.add(winDef.withWindowName(windowName)); } )*
        { plainSelect.setWindowDefinitions(winDefs); }
    ]
    [LOOKAHEAD(<K_ORDER> <K_BY>) orderByElements = OrderByElements() { plainSelect.setOrderByElements(orderByElements);    }   ]
    [ <K_EMIT> <K_CHANGES> { plainSelect.setEmitChanges(true); } ]
    [LOOKAHEAD(<K_LIMIT>) limit = LimitWithOffset() { plainSelect.setLimit(limit);    } ]
    [LOOKAHEAD(<K_OFFSET>) offset = Offset() { plainSelect.setOffset(offset);    } ]
	[LOOKAHEAD(<K_LIMIT>, { limit==null }) limit = LimitWithOffset() { plainSelect.setLimit(limit);    } ]
    [LOOKAHEAD(<K_FETCH>) fetch = Fetch() { plainSelect.setFetch(fetch);    } ]
    [LOOKAHEAD(<K_WITH> <K_ISOLATION>) withIsolation = WithIsolation() { plainSelect.setWithIsolation(withIsolation);    } ]
    [LOOKAHEAD(2) <K_FOR> <K_UPDATE> { plainSelect.setForUpdate(true); }
        [ <K_OF> updateTable = Table() { plainSelect.setForUpdateTable(updateTable); } ]
        [ LOOKAHEAD(<K_WAIT>) wait = Wait() { plainSelect.setWait(wait); } ]
        [ <K_NOWAIT> { plainSelect.setNoWait(true); } ] ]

    [LOOKAHEAD(<K_OPTIMIZE>) optimize = OptimizeFor() { plainSelect.setOptimizeFor(optimize); } ]

    [LOOKAHEAD(3) <K_FOR> <K_XML> <K_PATH> "(" token = <S_CHAR_LITERAL> ")" { plainSelect.setForXmlPath(token.image); } ]

    {
        plainSelect.setSelectItems(selectItems);
        plainSelect.setFromItem(fromItem);
        if (joins != null && joins.size() > 0)
            plainSelect.setJoins(joins);
        linkAST(plainSelect,jjtThis);
        return plainSelect;
    }
}

SelectBody SetOperationList() #SetOperationList: {
    SetOperationList list = new SetOperationList();
    List<OrderByElement> orderByElements = null;
    Limit limit = null;
    Offset offset = null;
    Fetch fetch = null;
    WithIsolation withIsolation = null;
    SelectBody select = null;
    List<SelectBody> selects = new ArrayList<SelectBody>();
    List<SetOperation> operations = new ArrayList<SetOperation>();
    List<Boolean> brackets = new ArrayList<Boolean>();
    boolean bracket = false;
}
{
    (("(" select=SelectBody() ")" { bracket=true;} )
                    | ( select=PlainSelect() | select=Values() ) { bracket=false;} ) {selects.add(select);brackets.add(bracket); }   
    ( LOOKAHEAD(2)
        ((<K_UNION> { UnionOp union = new UnionOp();linkAST(union,jjtThis);operations.add(union); } [ <K_ALL> { union.setAll(true); } | <K_DISTINCT> { union.setDistinct(true); } ])
        | <K_INTERSECT> { operations.add(new IntersectOp()); }
        | <K_MINUS> { operations.add(new MinusOp()); }
        | <K_EXCEPT> { operations.add(new ExceptOp()); }
        )

        (("(" select=SelectBody() ")" { bracket=true;} ) | ( select=PlainSelect() | select=Values() ) { bracket=false;} ) {selects.add(select);brackets.add(bracket);}
    )*


    [ LOOKAHEAD(2) orderByElements=OrderByElements() {list.setOrderByElements(orderByElements);} ]
    [LOOKAHEAD(<K_LIMIT>) limit=LimitWithOffset() {list.setLimit(limit);} ]
    [LOOKAHEAD(<K_OFFSET>) offset = Offset() { list.setOffset(offset);} ]
    [LOOKAHEAD(<K_FETCH>) fetch = Fetch() { list.setFetch(fetch);} ]
    [LOOKAHEAD(<K_WITH> <K_ISOLATION>) withIsolation = WithIsolation() { list.setWithIsolation(withIsolation);} ]

    {
        if (selects.size()==1 && selects.get(0) instanceof PlainSelect && orderByElements==null) {
            if (brackets.get(0)) {
                if (limit==null && offset==null && fetch==null && withIsolation==null)
                    ((PlainSelect)selects.get(0)).setUseBrackets(true);
                else {
                    list.setBracketsOpsAndSelects(brackets,selects,operations);
                    return list;    //brackets with outside limit, offset
                }
            }
            return selects.get(0);
        } else {
            if (selects.size()>1 && selects.get(selects.size()-1) instanceof PlainSelect && !brackets.get(brackets.size() - 1)) {
                PlainSelect ps = (PlainSelect)selects.get(selects.size()-1);
                if (ps.getOrderByElements() != null) {
                    list.setOrderByElements(ps.getOrderByElements());
                    list.setLimit(ps.getLimit());
                    list.setOffset(ps.getOffset());
                    ps.setOrderByElements(null);
                    ps.setLimit(null);
                    ps.setOffset(null);
                }
                if (ps.getFetch() != null) {
                    list.setFetch(ps.getFetch());
                    ps.setFetch(null);
                }
                if (ps.getWithIsolation() != null) {
                    list.setWithIsolation(ps.getWithIsolation());
                    ps.setWithIsolation(null);
                }
            }
            list.setBracketsOpsAndSelects(brackets,selects,operations);
            return list;
        }
    }
}

SelectBody SetOperationListWithoutIntialSelect(FromItem fromItem) #SetOperationList:
{
    SetOperationList list = new SetOperationList();
    List<OrderByElement> orderByElements = null;
    Limit limit = null;
    Offset offset = null;
    Fetch fetch = null;
    WithIsolation withIsolation = null;
    SelectBody select;
    List<SelectBody> selects = new ArrayList<SelectBody>();
    List<SetOperation> operations = new ArrayList<SetOperation>();
    List<Boolean> brackets = new ArrayList<Boolean>();
    boolean bracket = false;
}
{
    {
        while (fromItem instanceof ParenthesisFromItem) {
            fromItem = ((ParenthesisFromItem)fromItem).getFromItem();
        }

        if (fromItem instanceof SubSelect) {
            select = ((SubSelect)fromItem).getSelectBody();
        } else {
            throw new IllegalArgumentException("this type of set operation is not allowed");
        }

        selects.add(select);
        brackets.add(true);
    } 
    ( LOOKAHEAD(2) 
        ((<K_UNION> { UnionOp union = new UnionOp();linkAST(union,jjtThis);operations.add(union); } [ <K_ALL> { union.setAll(true); } | <K_DISTINCT> { union.setDistinct(true); } ])
        | <K_INTERSECT> { operations.add(new IntersectOp()); }
        | <K_MINUS> { operations.add(new MinusOp()); }
        | <K_EXCEPT> { operations.add(new ExceptOp()); }
        )

        "(" select=SelectBody() ")" { bracket=true;}  {selects.add(select);brackets.add(bracket);}
    )+

    {
        list.setBracketsOpsAndSelects(brackets,selects,operations);
        return list;
    }
}

List<WithItem> WithList():
{
    List<WithItem> withItemsList = new ArrayList<WithItem>();
    WithItem with = null;
}
{
    <K_WITH> with=WithItem() { withItemsList.add(with); } ("," with=WithItem() { withItemsList.add(with); } )*

     { return withItemsList; }
}

WithItem WithItem() #WithItem:
{
    WithItem with = new WithItem();
    String name = null;
    List<SelectItem> selectItems = null;
    SubSelect select = null;

    ExpressionList simpleExpressionList;
}
{
     [ <K_RECURSIVE> { with.setRecursive(true); } ] name=RelObjectName() { with.setName(name); }
     [ "(" selectItems=SelectItemsList() ")" { with.setWithItemList(selectItems); } ]
     <K_AS>
    // if the next block looks alike an ExpressionList without Brackets, then parse as List
    ( LOOKAHEAD( "(" <K_VALUES> SimpleExpressionList(true) ")" ) 
        "(" <K_VALUES>
            simpleExpressionList = SimpleExpressionList(true) { with.withUseBracketsForValues(false).setItemsList(simpleExpressionList); }
        ")"

    // Otherwise parse it as a SubSelect
        | "(" select = SubSelect() { with.setSubSelect(select.withUseBrackets(false)); with.setUseValues(false); } ")"
            
    )
     { return with; }
}

List<SelectItem> SelectItemsList():
{
    List<SelectItem> selectItemsList = new ArrayList<SelectItem>();
    SelectItem selectItem = null;
}
{
    selectItem=SelectItem() { selectItemsList.add(selectItem); } ( LOOKAHEAD(2) "," selectItem=SelectItem() { selectItemsList.add(selectItem); } )*

    { return selectItemsList; }
}

SelectExpressionItem SelectExpressionItem():
{
    SelectExpressionItem selectExpressionItem = null;
    Expression expression = null;
    Alias alias = null;
}
{
      expression=Expression() { selectExpressionItem = new SelectExpressionItem(); selectExpressionItem.setExpression(expression); }
      [ LOOKAHEAD(2)  alias=Alias() { selectExpressionItem.setAlias(alias); }] { return selectExpressionItem; }
}

SelectItem SelectItem() #SelectItem:
{
    SelectItem selectItem = null;
}
{   ("*" { selectItem = new AllColumns(); }
    |
    LOOKAHEAD(AllTableColumns()) selectItem=AllTableColumns()
    |
    selectItem=SelectExpressionItem()
    )
    {
        linkAST(selectItem,jjtThis);
        return selectItem;
    }
}

AllTableColumns AllTableColumns():
{
    Table table = null;
}
{
     table=Table() "." "*"
    {
        return new AllTableColumns(table);
    }

}

Alias Alias():
{ String name = null;
  Token token = null;
  boolean useAs = false;
  Alias alias;
  String colname;
  ColDataType colDataType = null;
}
{
    [<K_AS> { useAs = true; } ]
	( name=RelObjectNameWithoutStart() | token=<S_CHAR_LITERAL> { name=token.image; } )
	{ alias = new Alias(name,useAs); }

	[ LOOKAHEAD(2) "(" { List<Alias.AliasColumn> list = new ArrayList<Alias.AliasColumn>(); }
		colname = RelObjectName() [ colDataType = ColDataType() ] { list.add(new Alias.AliasColumn(colname, colDataType)); }
		("," { colDataType=null; } colname = RelObjectName() [ colDataType = ColDataType()] { list.add(new Alias.AliasColumn(colname, colDataType)); } )*
	")" { alias.setAliasColumns(list); } ]

    { return alias; }
}

void SQLServerHint(SQLServerHints hints) : {
    String str;
}
{
        <K_INDEX> "(" str = RelObjectName() ")" { hints.setIndexName(str); }
        |
        <K_NOLOCK> { hints.withNoLock(); }
}

SQLServerHints SQLServerHints() : {
    SQLServerHints hints = new SQLServerHints();
}
{
    <K_WITH> "("
        SQLServerHint(hints) ("," SQLServerHint(hints) )*
    ")"
    { return hints; }
}

MySQLIndexHint MySQLIndexHint():
{
	Token actionToken = null;
	Token indexToken = null;
	String indexName = null;
	List<String> indexNameList = new ArrayList<String>();
}
{
	(
	actionToken = <K_USE>
	| actionToken = <K_SHOW>
	| actionToken = <K_IGNORE>
	| actionToken = <K_FORCE>
	)

	(
	indexToken = <K_INDEX>
	| indexToken = <K_KEY>
	)

	"("
	indexName = RelObjectNameWithoutValue() { indexNameList.add(indexName); }
	("," indexName= RelObjectNameWithoutValue() { indexNameList.add(indexName); })*
	")"
	{
		return new MySQLIndexHint(actionToken.image, indexToken.image, indexNameList);
	}
}

 FunctionItem FunctionItem():
{
    Alias alias = null;
    Function function;
     FunctionItem functionItem;
}
{
    function=Function() { functionItem = new FunctionItem(); functionItem.setFunction(function); }
             [alias=Alias() { functionItem.setAlias(alias); }]
    { return functionItem; }
}

List<Column> PivotForColumns():
{
    List<Column> columns = new ArrayList<Column>();
    Column column;
}
{
    (
        ("(" column = Column() { columns.add(column); }
         ("," column = Column() { columns.add(column); } )*
         ")")
    | column = Column() { columns.add(column); }
    )
    { return columns; }
}

List<FunctionItem> PivotFunctionItems():
{
    List< FunctionItem> functionItems = new ArrayList< FunctionItem>();
    FunctionItem item;
}
{
    item = FunctionItem() {functionItems.add(item);}
    ( "," item = FunctionItem() {functionItems.add(item);} )*
    { return functionItems; }
}

List<SelectExpressionItem> PivotSingleInItems():
{
   List<SelectExpressionItem> retval = new ArrayList<SelectExpressionItem>();
   SelectExpressionItem item;
}
{
   item = PivotSelectExprItem() {retval.add(item);}
   ("," item = PivotSelectExprItem() {retval.add(item);} )*
   { return retval; }
}

SelectExpressionItem PivotSelectExprItem():
{
    SelectExpressionItem selectExpressionItem = null;
    Expression expression = null;
    Alias alias = null;
}
{
      expression=SimpleExpression() { selectExpressionItem = new SelectExpressionItem(); selectExpressionItem.setExpression(expression); }
             [alias=Alias() { selectExpressionItem.setAlias(alias); }] { return selectExpressionItem; }
}

ExpressionListItem ExpressionListItem():
{
    ExpressionListItem expressionListItem = null;
    ExpressionList expressionList = null;
    Alias alias = null;
}
{
    "("
    expressionList=SimpleExpressionList(true) { expressionListItem = new ExpressionListItem(); expressionListItem.setExpressionList(expressionList); }
    ")"
    [alias=Alias() { expressionListItem.setAlias(alias); }]
    { return expressionListItem; }
}

List<ExpressionListItem> PivotMultiInItems():
{
   List<ExpressionListItem> retval = new ArrayList<ExpressionListItem>();
   ExpressionListItem item;
}
{
   item = ExpressionListItem() {retval.add(item);}
   ("," item = ExpressionListItem() {retval.add(item);} )*
   { return retval; }
}

Pivot Pivot():
{
    Pivot retval = new Pivot();
    List<FunctionItem> functionItems;
    List<Column> forColumns;
    List<SelectExpressionItem> singleInItems = null;
    List<ExpressionListItem> multiInItems = null;
    Alias alias = null;
}
{
    <K_PIVOT> "(" functionItems = PivotFunctionItems() <K_FOR>
    forColumns = PivotForColumns()
    <K_IN> "("
    (LOOKAHEAD(3) singleInItems = PivotSingleInItems()
    | multiInItems = PivotMultiInItems() )
    ")"
    ")"
    [ alias = Alias() ]
    {
        retval.setFunctionItems(functionItems);
        retval.setForColumns(forColumns);
        retval.setSingleInItems(singleInItems);
        retval.setMultiInItems(multiInItems);
        retval.setAlias(alias);
        return retval;
    }
}

PivotXml PivotXml():
{
    PivotXml retval = new PivotXml();
    List<FunctionItem> functionItems;
    List<Column> forColumns;
    List<SelectExpressionItem> singleInItems = null;
    List<ExpressionListItem> multiInItems = null;
    SelectBody inSelect = null;
}
{
    <K_PIVOT> <K_XML> "(" functionItems = PivotFunctionItems() <K_FOR>
    forColumns = PivotForColumns()
    <K_IN> "("
    (
        LOOKAHEAD(2) <K_ANY> { retval.setInAny(true); } |
        LOOKAHEAD(1) inSelect = SelectBody() |
        LOOKAHEAD(2) singleInItems = PivotSingleInItems() |
        multiInItems = PivotMultiInItems()
    )
    ")"
    ")"
    {
        retval.setFunctionItems(functionItems);
        retval.setForColumns(forColumns);
        retval.setSingleInItems(singleInItems);
        retval.setMultiInItems(multiInItems);
        retval.setInSelect(inSelect);
        return retval;
    }
}

UnPivot UnPivot():
{
    UnPivot retval = new UnPivot();
    List<Column> unpivotClause;
    List<Column> unpivotForClause;
    List<SelectExpressionItem> unpivotInClause;
    Alias alias = null;
}
{
    <K_UNPIVOT>
    [ ( <K_INCLUDE> <K_NULLS> { retval.setIncludeNulls(true); }
    | <K_EXCLUDE> <K_NULLS> { retval.setIncludeNulls(false); } ) ]
    "(" unpivotClause = PivotForColumns() <K_FOR>
    unpivotForClause = PivotForColumns()
    <K_IN> "("
    unpivotInClause = PivotSingleInItems()
    ")"
    ")"
    [ LOOKAHEAD(2) alias = Alias() ]
    {
        retval.setUnPivotClause(unpivotClause);
        retval.setUnPivotForClause(unpivotForClause);
        retval.setUnPivotInClause(unpivotInClause);
        retval.setAlias(alias);
        return retval;
    }
}

List<Table> IntoClause():
{
    List<Table> tables = new ArrayList<Table>();
    Table table;
}
{
    <K_INTO> table=Table() { tables.add(table); } ( LOOKAHEAD(2) "," table=Table() { tables.add(table); } )*
    {
        return tables;
    }
}

FromItem FromItem():
{
    FromItem fromItem = null;
    FromItem fromItem2 = null;
    Pivot pivot = null;
    UnPivot unpivot = null;
    Alias alias = null;
    MySQLIndexHint indexHint = null;
    SQLServerHints sqlServerHints = null;
    SelectBody selectBody;
}
{
    (
        LOOKAHEAD(ValuesList()) fromItem=ValuesList()
        |
        (
            (
                (
                    "("
                        (
                        LOOKAHEAD(3) fromItem2=FromItem()
                          { fromItem = new ParenthesisFromItem(fromItem2); }
                        [ fromItem = SubJoin(fromItem2) ]
                        /* LOOKAHEAD(SubJoin())
                        fromItem=SubJoin() */
                        | 
                        fromItem=SubSelect()
                        )
                        [ selectBody = SetOperationListWithoutIntialSelect(fromItem) 
                            {   
                                if (!(selectBody instanceof PlainSelect)) {
                                    fromItem = new SubSelect().withSelectBody(selectBody); 
                                }
                            }
                        ]
                    ")"
                    [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ]
                )
                |
                LOOKAHEAD(TableFunction())
                fromItem=TableFunction()
                |
                fromItem=Table()
                |
                fromItem=LateralSubSelect()
            )
            [ alias=Alias() { fromItem.setAlias(alias); } ]
			[ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ]
			[(LOOKAHEAD(2) pivot=PivotXml()|pivot=Pivot()) { fromItem.setPivot(pivot); } ]
            [
                LOOKAHEAD(2)
                (
                    indexHint = MySQLIndexHint() {
                        if (fromItem instanceof Table)
                            ((Table) fromItem).setHint(indexHint);
                    }
                    |
                    sqlServerHints = SQLServerHints() {
                        if (fromItem instanceof Table)
                            ((Table) fromItem).setSqlServerHints(sqlServerHints);
                    }
                )
            ]
        )
    )
    {
        return fromItem;
    }
}

FromItem ValuesList():
{
    MultiExpressionList exprList = new MultiExpressionList();
    List<Expression> primaryExpList = new ArrayList<Expression>();
    ValuesList valuesList = new ValuesList();
    Expression exp = null;
    List<String> colNames = null;
    String colName;
    Alias alias;
}
{
    "("
    <K_VALUES>
    (LOOKAHEAD(3) ("(" exp=SimpleExpression() { primaryExpList.add(exp); }
            ("," exp=SimpleExpression()  { primaryExpList.add(exp); } )* ")" { exprList.addExpressionList(primaryExpList); }

            ("," "(" exp=SimpleExpression() {
                    primaryExpList = new ArrayList<Expression>();
                    primaryExpList.add(exp); }
                ("," exp=SimpleExpression() { primaryExpList.add(exp); } )* ")" { exprList.addExpressionList(primaryExpList); } )*)
    |
    ( exp=SimpleExpression() { exprList.addExpressionList(exp); valuesList.setNoBrackets(true); }
        ("," exp=SimpleExpression()  { exprList.addExpressionList(exp);} )*
    ))
    ")"

    [ alias=Alias() { valuesList.setAlias(alias); }

        [ "("
            colName = RelObjectName() { colNames = new ArrayList<String>(); colNames.add(colName); }
            ( "," colName = RelObjectName() { colNames.add(colName); } )*
            ")" { valuesList.setColumnNames(colNames); } ]

    ]

    {
        valuesList.setMultiExpressionList(exprList);
        return valuesList;
    }
}

LateralSubSelect LateralSubSelect():
{
    LateralSubSelect specialSubSelect;
    SubSelect subSelect = null;
}
{
    <K_LATERAL> { specialSubSelect = new LateralSubSelect(); }
     "(" subSelect=SubSelect() ")"
    {
        specialSubSelect.setSubSelect(subSelect);
        return specialSubSelect;
    }
}

FromItem SubJoin(FromItem fromItem):
{
    Join join = null;
    List<Join> joinList = null;
}
{
    joinList=SubJoinsList()
    {
        SubJoin subJoin = new SubJoin();
        subJoin.setLeft(fromItem);
        subJoin.setJoinList(joinList);
        return subJoin;
    }
}

List<Join> JoinsList():
{
    List<Join> joinsList = new ArrayList<Join>();
    Join join = null;
}
{
    ( LOOKAHEAD(2) join=JoinerExpression() { joinsList.add(join); })*
    { return joinsList; }
}

List<Join> SubJoinsList():
{
    List<Join> joinsList = new ArrayList<Join>();
    Join join = null;
}
{

    (join=JoinerExpression() { joinsList.add(join); })+
    { return joinsList; }
}


Join JoinerExpression() #JoinerExpression:
{
    Join join = new Join();
    FromItem right = null;
    Expression onExpression = null;
    Column tableColumn;
    List<Column> columns = null;
    KSQLJoinWindow joinWindow = null;

}
{
    [ <K_NATURAL> { join.setNatural(true); } ]

    [
        (
            <K_LEFT> { join.setLeft(true); } [ <K_SEMI> { join.setSemi(true); } | <K_OUTER> { join.setOuter(true); } ]
            |
            (
                <K_RIGHT> { join.setRight(true); }
                |
                <K_FULL> { join.setFull(true); }
            ) [ <K_OUTER> { join.setOuter(true); } ]
            |
            <K_INNER> { join.setInner(true); }
        )
        |
        <K_CROSS> { join.setCross(true); }
        |
        <K_OUTER> { join.setOuter(true); }
    ]

    (
        <K_JOIN>
        |
        "," { join.setSimple(true); } (<K_OUTER> { join.setOuter(true); } )?
        |
        <K_STRAIGHT> { join.setStraight(true); }
        |
        <K_APPLY> {join.setApply(true); }
    )

    right=FromItem()

    [
        LOOKAHEAD(2) (
                        [ <K_WITHIN> "(" joinWindow = JoinWindow() ")" {join.setJoinWindow(joinWindow);} ]
                        ( <K_ON> onExpression=Expression()  { join.addOnExpression(onExpression); }
                          ( LOOKAHEAD(2)  <K_ON> onExpression=Expression()  { join.addOnExpression(onExpression); } )*
                        )
                        |
                        (
                            <K_USING> "(" tableColumn=Column() { columns = new ArrayList<Column>(); columns.add(tableColumn); }
                            ( "," tableColumn=Column() { columns.add(tableColumn); } ) *
                            ")" { join.setUsingColumns(columns); }
                        )
                    )
    ]
  {
      linkAST(join,jjtThis);
      join.setRightItem(right);
    return join;
  }

}

KSQLJoinWindow JoinWindow():
{
    KSQLJoinWindow retval = new KSQLJoinWindow();
    boolean beforeAfter;
    Token beforeDurationToken = null;
    Token beforeTimeUnitToken = null;
    Token afterDurationToken = null;
    Token afterTimeUnitToken = null;
}
{
    (beforeDurationToken=<S_LONG> (beforeTimeUnitToken=<S_IDENTIFIER> | beforeTimeUnitToken=<K_DATE_LITERAL>)
        [ "," afterDurationToken=<S_LONG> (afterTimeUnitToken=<S_IDENTIFIER> | afterTimeUnitToken=<K_DATE_LITERAL>) ]
    {
        if (afterDurationToken == null) {
            retval.setDuration(Long.parseLong(beforeDurationToken.image));
            retval.setTimeUnit(KSQLJoinWindow.TimeUnit.valueOf(beforeTimeUnitToken.image));
            retval.setBeforeAfterWindow(false);
            return retval;
        }
        retval.setBeforeDuration(Long.parseLong(beforeDurationToken.image));
        retval.setBeforeTimeUnit(KSQLJoinWindow.TimeUnit.valueOf(beforeTimeUnitToken.image));
        retval.setAfterDuration(Long.parseLong(afterDurationToken.image));
        retval.setAfterTimeUnit(KSQLJoinWindow.TimeUnit.valueOf(afterTimeUnitToken.image));
        retval.setBeforeAfterWindow(true);
        return retval;
    })
}

KSQLWindow KSQLWindowClause():
{
    KSQLWindow retval = null;
    Token sizeDurationToken = null;
    Token sizeTimeUnitToken = null;
    Token advanceDurationToken = null;
    Token advanceTimeUnitToken = null;
}
{
    <K_WINDOW>
    {
        retval=new KSQLWindow();
        retval.setHoppingWindow(false);
        retval.setSessionWindow(false);
        retval.setTumblingWindow(false);
    }
    (
        <K_HOPPING> "("
            <K_SIZE> sizeDurationToken=<S_LONG> sizeTimeUnitToken=<S_IDENTIFIER> ","
            <K_ADVANCE> <K_BY> advanceDurationToken=<S_LONG> advanceTimeUnitToken=<S_IDENTIFIER> ")"
        {
            retval.setHoppingWindow(true);
        } |
        <K_SESSION> "(" sizeDurationToken=<S_LONG> sizeTimeUnitToken=<S_IDENTIFIER> ")"
        {
            retval.setSessionWindow(true);
        } |
        <K_TUMBLING> "(" <K_SIZE> sizeDurationToken=<S_LONG> sizeTimeUnitToken=<S_IDENTIFIER> ")"
        {
            retval.setTumblingWindow(true);
        }
    )
    {
            retval.setSizeDuration(Long.parseLong(sizeDurationToken.image));
            retval.setSizeTimeUnit(KSQLWindow.TimeUnit.valueOf(sizeTimeUnitToken.image));
            if (advanceDurationToken != null) {
                retval.setAdvanceDuration(Long.parseLong(advanceDurationToken.image));
                retval.setAdvanceTimeUnit(KSQLWindow.TimeUnit.valueOf(advanceTimeUnitToken.image));
            }
            return retval;
    }
}

Expression WhereClause():
{
    Expression retval = null;
}
{
    <K_WHERE> retval=Expression()
    { return retval; }
}

OracleHierarchicalExpression OracleHierarchicalQueryClause():
{
    OracleHierarchicalExpression result = new OracleHierarchicalExpression();
    Expression expr;
}
{
    (
                <K_START> <K_WITH>  expr=AndExpression() {result.setStartExpression(expr);}
                <K_CONNECT> <K_BY> [ <K_NOCYCLE> { result.setNoCycle(true); } ] expr=AndExpression()
                { result.setConnectExpression(expr); }
            |
                <K_CONNECT> <K_BY> [ <K_NOCYCLE> { result.setNoCycle(true); } ] expr=AndExpression()
                {
                    result.setConnectExpression(expr);
                    result.setConnectFirst(true);
                }
                [ <K_START> <K_WITH>  expr=AndExpression() {result.setStartExpression(expr);} ]
    )
    {
        return result;
    }
}

GroupByElement GroupByColumnReferences():
{
    Expression columnReference;
    GroupByElement groupBy = new GroupByElement();
    Expression expr;
    ExpressionList list;
}
{
    <K_GROUP> <K_BY>
    (     LOOKAHEAD(2) (
              "(" ")" { groupBy.withUsingBrackets(true); }
              (
                LOOKAHEAD(2) (
                  <K_GROUPING> <K_SETS> "("
                      ( LOOKAHEAD(2) "(" ")" { groupBy.addGroupingSet(new ExpressionList()); }
                          | LOOKAHEAD(3) "(" list = SimpleExpressionList(true) ")" { groupBy.addGroupingSet(list); }
                          | expr = SimpleExpression() { groupBy.addGroupingSet(expr); } )

                      ( "," ( LOOKAHEAD(2) "(" ")" { groupBy.addGroupingSet(new ExpressionList()); }
                          | LOOKAHEAD(3) "(" list = SimpleExpressionList(true) ")" { groupBy.addGroupingSet(list); }
                          | expr = SimpleExpression() { groupBy.addGroupingSet(expr); } ) )*
                  ")"
                )
              )?
          )
          |
          LOOKAHEAD(2) ( 
            <K_GROUPING> <K_SETS> "("
                ( LOOKAHEAD(2) "(" ")" { groupBy.addGroupingSet(new ExpressionList()); }
                    | LOOKAHEAD(3) "(" list = SimpleExpressionList(true) ")" { groupBy.addGroupingSet(list); }
                    | expr = SimpleExpression() { groupBy.addGroupingSet(expr); } )

                ( "," ( LOOKAHEAD(2) "(" ")" { groupBy.addGroupingSet(new ExpressionList()); }
                    | LOOKAHEAD(3) "(" list = SimpleExpressionList(true) ")" { groupBy.addGroupingSet(list); }
                    | expr = SimpleExpression() { groupBy.addGroupingSet(expr); } ) )*
            ")"
          )
          |
          LOOKAHEAD(2) (  
            list = ComplexExpressionList() { groupBy.setGroupByExpressionList(list.withUsingBrackets(false)); }
            (
              LOOKAHEAD(2) (
                <K_GROUPING> <K_SETS> "("
                    ( LOOKAHEAD(2) "(" ")" { groupBy.addGroupingSet(new ExpressionList()); }
                        | LOOKAHEAD(3) "(" list = SimpleExpressionList(true) ")" { groupBy.addGroupingSet(list); }
                        | expr = SimpleExpression() { groupBy.addGroupingSet(expr); } )

                    ( "," ( LOOKAHEAD(2) "(" ")" { groupBy.addGroupingSet(new ExpressionList()); }
                        | LOOKAHEAD(3) "(" list = SimpleExpressionList(true) ")" { groupBy.addGroupingSet(list); }
                        | expr = SimpleExpression() { groupBy.addGroupingSet(expr); } ) )*
                ")"
              )
            )?
          )
    )
    {
        return groupBy;
    }
}

Expression Having():
{
    Expression having = null;
}
{
    <K_HAVING> having=Expression()
    {
        return having;
    }
}

List<OrderByElement> OrderByElements():
{
    List<OrderByElement> orderByList = new ArrayList<OrderByElement>();
    OrderByElement orderByElement = null;
}
{
    <K_ORDER> [ <K_SIBLINGS> ] <K_BY> orderByElement=OrderByElement() { orderByList.add(orderByElement); }
        ( LOOKAHEAD(2) "," orderByElement=OrderByElement() { orderByList.add(orderByElement); } )*
    {
        return orderByList;
    }
}

OrderByElement OrderByElement():
{
    OrderByElement orderByElement = new OrderByElement();
    Expression columnReference = null;
}
{
    columnReference = Expression()
    [ ( <K_ASC> | (<K_DESC> { orderByElement.setAsc(false); } )) { orderByElement.setAscDescPresent(true); }  ]
    [<K_NULLS> (
        <K_FIRST> { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_FIRST);  }  |
        <K_LAST> { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_LAST);  }
        )?
    ]
    {
        orderByElement.setExpression(columnReference);
        return orderByElement;
    }
}

JdbcParameter SimpleJdbcParameter() : {
    JdbcParameter retval;
}
{
    "?" { retval = new JdbcParameter(++jdbcParameterIndex, false); }
		[ LOOKAHEAD(2) token = <S_LONG> { retval.setUseFixedIndex(true); retval.setIndex(Integer.valueOf(token.image)); } ]
    {
        return retval;
    }
}

JdbcNamedParameter SimpleJdbcNamedParameter() : {
    String name;
}
{
    ":" name = RelObjectNameExt()
    {
        return new JdbcNamedParameter(token.image);
    }
}

Limit LimitWithOffset() #LimitWithOffset:
{
    Limit limit = new Limit();
    Expression rowCountExpression;
    Expression offsetExpression;
}
{
    (
        LOOKAHEAD(<K_LIMIT> Expression() "," Expression()) (
            // mysql-> LIMIT offset,row_count
            <K_LIMIT>
            offsetExpression=Expression() { limit.setOffset( offsetExpression ); }
            ","
            rowCountExpression=Expression() { limit.setRowCount( rowCountExpression ); }
        )
        |
        limit = PlainLimit()
    )
    {
        linkAST(limit,jjtThis);
        return limit;
    }
}

Limit PlainLimit() #PlainLimit:
{
    Limit limit = new Limit();
    Expression rowCountExpression;
}
{
    // mysql-postgresql-> LIMIT (row_count | ALL | NULL)
    <K_LIMIT>
     (
        (
            LOOKAHEAD(3) "(" rowCountExpression = SubSelect() ")"
            |
            rowCountExpression = Expression()
        ) { limit.setRowCount(rowCountExpression); }
     )
    {
        linkAST(limit,jjtThis);
        return limit;
    }
}

Offset Offset():
{
    Offset offset = new Offset();
    Expression offsetExpression;
}
{
    (
            // postgresql-> OFFSET offset
            // sqlserver-oracle-> OFFSET offset (ROW | ROWS)
             <K_OFFSET>
             offsetExpression=Expression() { offset.setOffset( offsetExpression ); }

             [(<K_ROWS> { offset.setOffsetParam("ROWS"); } | <K_ROW> { offset.setOffsetParam("ROW"); })]

        )
    {
        return offset;
    }
}

Fetch Fetch():
{
    Fetch fetch = new Fetch();
    Token token = null;
    JdbcParameter jdbc;
}
{
    (
            // sqlserver-oracle-> FETCH (FIRST | NEXT) row_count (ROW | ROWS) ONLY
             <K_FETCH>
                  (<K_FIRST> { fetch.setFetchParamFirst(true); } | <K_NEXT>)
                 (token=<S_LONG> { fetch.setRowCount(Long.parseLong(token.image)); }
                 | jdbc = SimpleJdbcParameter() { fetch.setFetchJdbcParameter(jdbc); } ) /* "?" { fetch.setFetchJdbcParameter(true); } ) */
                 (<K_ROWS> { fetch.setFetchParam("ROWS"); } | <K_ROW>)
                 <K_ONLY>

        )
    {
        return fetch;
    }
}

WithIsolation WithIsolation():
{
    WithIsolation withIsolation = new WithIsolation();
    Token token = null;
    JdbcParameter jdbc;
}
{
    (
            //with (ur | cs | rs | rr)
             <K_WITH>
             token=<K_ISOLATION> { withIsolation.setIsolation(token.image); }

        )
    {
        return withIsolation;
    }
}

OptimizeFor OptimizeFor():
{
    Token token;
    LongValue value;
}
{
    <K_OPTIMIZE> <K_FOR> token=<S_LONG> <K_ROWS> { value = new LongValue(token.image); }
    {
        return new OptimizeFor(value.getValue());
    }
}

// according to http://technet.microsoft.com/en-us/library/ms189463.aspx
Top Top():
{
    Top top = new Top();
    Token token = null;
    Expression expr = null;
    JdbcParameter jdbc = null;
}
{
    <K_TOP>
    (
         token=<S_LONG>                      { top.setExpression(new LongValue(token.image)); }
       |
         jdbc = SimpleJdbcParameter() { top.setExpression(jdbc); }
         /*"?"                                 { top.setExpression(new JdbcParameter(++jdbcParameterIndex, false)); } [ LOOKAHEAD(2) token = <S_LONG> { ((JdbcParameter)(top.getExpression())).setUseFixedIndex(true); ((JdbcParameter)(top.getExpression())).setIndex(Integer.valueOf(token.image)); } ]*/
       |
       ":"                                  { top.setExpression(new JdbcNamedParameter()); } [ LOOKAHEAD(2) token = <S_IDENTIFIER> { ((JdbcNamedParameter)top.getExpression()).setName(token.image); } ]
       |
       "("
            expr=AdditiveExpression()   { top.setExpression(expr); }
            { top.setParenthesis(true);}
       ")"
    ) [ LOOKAHEAD(2) <K_PERCENT>            { top.setPercentage(true); } ]
      [ LOOKAHEAD(2) <K_WITH_TIES>            { top.setWithTies(true); }]
    {
        return top;
    }
}

// according to http://www-01.ibm.com/support/knowledgecenter/SSGU8G_12.1.0/com.ibm.sqls.doc/ids_sqs_0156.htm
Skip Skip():
{
    Skip skip = new Skip();
    Token token = null;
    JdbcParameter jdbc;
}
{
    <K_SKIP>
    (
         token=<S_LONG>                      { skip.setRowCount(Long.parseLong(token.image)); }
                | token=<S_IDENTIFIER>              { skip.setVariable(token.image); }
                | jdbc = SimpleJdbcParameter() { skip.setJdbcParameter(jdbc); }
                   /* "?" { skip.setJdbcParameter(new JdbcParameter(++jdbcParameterIndex, false)); } [ LOOKAHEAD(2) token = <S_LONG> { skip.getJdbcParameter().setUseFixedIndex(true); skip.getJdbcParameter().setIndex(Integer.valueOf(token.image)); } ] */
    )
    {
        return skip;
    }
}

JAVACODE
OracleHint getOracleHint() {
  OracleHint hint = null;
  Token tok = getToken(1);
  // Retrieve first comment (if any) prior next token
  if (tok.specialToken != null) {
    tok = tok.specialToken;
    while (tok.specialToken != null) tok = tok.specialToken;
    // Check if it matches Hint pattern?
    if (OracleHint.isHintMatch(tok.image)) {
      hint = new OracleHint();
      hint.setComment(tok.image);
    }
  }
  return hint;
}

First First():
{
    First first = new First();
    Token token = null;
    JdbcParameter jdbc;
}
{
    ( <K_FIRST>                                 { first.setKeyword(First.Keyword.FIRST); }
            |  <K_LIMIT>                            { first.setKeyword(First.Keyword.LIMIT); }
        )
    (
         token=<S_LONG>                      { first.setRowCount(Long.parseLong(token.image)); }
                | token=<S_IDENTIFIER>              { first.setVariable(token.image); }
                | jdbc = SimpleJdbcParameter() { first.setJdbcParameter(jdbc); }
                    /* "?" { first.setJdbcParameter(new JdbcParameter(++jdbcParameterIndex, false)); } [ LOOKAHEAD(2) token = <S_LONG> { first.getJdbcParameter().setUseFixedIndex(true); first.getJdbcParameter().setIndex(Integer.valueOf(token.image)); } ] */
    )
    {
        return first;
    }
}


Expression Expression() #Expression :
{
    Expression retval = null;
}
{
    retval=XorExpression()

    { return retval; }
}

Expression XorExpression():
{
    Expression left, right, result;
}
{
    left=OrExpression() { result = left; }
    ( LOOKAHEAD(2)
        <K_XOR>
        right=OrExpression()
        {
            result = new XorExpression(left, right);
            left = result;
        }
     )*
     {
         return result;
     }
}

Expression OrExpression():
{
    Expression left, right, result;
}
{
    left=AndExpression() { result = left; }
    ( LOOKAHEAD(2)
        <K_OR>
        right=AndExpression()
        {
            result = new OrExpression(left, right);
            left = result;
        }
     )*
     {
         return result;
     }

}

Expression AndExpression() :
{
    Expression left, right, result;
    boolean not = false;
	boolean exclamationMarkNot=false;
}
{
    (
        LOOKAHEAD(Condition())
        left=Condition()
        |
        [ <K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; } ]
        "(" left=XorExpression() ")" {left = new Parenthesis(left); if (not) { left = new NotExpression(left, exclamationMarkNot); not = false; } }
    )
    { result = left; }

    ( LOOKAHEAD(2)
        { boolean useOperator = false; }
         (<K_AND> | <K_AND_OPERATOR> {useOperator=true;} )
        (
        LOOKAHEAD(Condition())
            right=Condition()
            |
            [ <K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; } ]
            "(" right=XorExpression() ")" {right = new Parenthesis(right); if (not) { right = new NotExpression(right, exclamationMarkNot); not = false; } }
        )
        {
            result = new AndExpression(left, right);
            ((AndExpression)result).setUseOperator(useOperator);
            left = result;
        }
    )*
    {
        return result;
    }
}

Expression Condition():
{
    Expression result;
    Token token;
    boolean not = false;
	boolean exclamationMarkNot = false;
}
{
    [ LOOKAHEAD(2) (<K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; })]
    (
        LOOKAHEAD(RegularCondition()) result=RegularCondition()
        | result=SQLCondition()
    )

    { return not?new NotExpression(result, exclamationMarkNot):result; }
}

Expression RegularCondition() #RegularCondition:
{
    Expression result = null;
    Expression leftExpression;
    Expression rightExpression;
    int oracleJoin=EqualsTo.NO_ORACLE_JOIN;
    int oraclePrior=EqualsTo.NO_ORACLE_PRIOR;
    boolean binary = false;
    boolean not = false;
}
{
    [ LOOKAHEAD(2) <K_PRIOR> { oraclePrior = EqualsTo.ORACLE_PRIOR_START; }]
    leftExpression=ComparisonItem() { result = leftExpression; }

    [ "(" "+" ")" { oracleJoin=EqualsTo.ORACLE_JOIN_RIGHT; } ]

    ( LOOKAHEAD(2)
    ">" { result = new GreaterThan(); }
    | "<" { result = new MinorThan(); }
    | "=" { result = new EqualsTo(); }
    | token=<OP_GREATERTHANEQUALS> { result = new GreaterThanEquals(token.image); }
    | token=<OP_MINORTHANEQUALS> { result = new MinorThanEquals(token.image); }
    | token=<OP_NOTEQUALSSTANDARD> { result = new NotEqualsTo(token.image); }
    | token=<OP_NOTEQUALSBANG> { result = new NotEqualsTo(token.image); }
    | "@@" { result = new Matches(); }
    | "~" { result = new RegExpMatchOperator(RegExpMatchOperatorType.MATCH_CASESENSITIVE); }
    | [<K_NOT> { not=true; } ] <K_REGEXP> [ <K_BINARY> { binary=true; } ] { result = new RegExpMySQLOperator(not, binary?RegExpMatchOperatorType.MATCH_CASESENSITIVE:RegExpMatchOperatorType.MATCH_CASEINSENSITIVE); }
    | <K_RLIKE> [ <K_BINARY> { binary=true; } ] { result = new RegExpMySQLOperator(binary?RegExpMatchOperatorType.MATCH_CASESENSITIVE:RegExpMatchOperatorType.MATCH_CASEINSENSITIVE).useRLike(); }
    | "~*" { result = new RegExpMatchOperator(RegExpMatchOperatorType.MATCH_CASEINSENSITIVE); }
    | "!~" { result = new RegExpMatchOperator(RegExpMatchOperatorType.NOT_MATCH_CASESENSITIVE); }
    | "!~*" { result = new RegExpMatchOperator(RegExpMatchOperatorType.NOT_MATCH_CASEINSENSITIVE); }

        | "@>" { result = new JsonOperator("@>"); }
        | "<@" { result = new JsonOperator("<@"); }
        | "?" { result = new JsonOperator("?"); }
        | "?|" { result = new JsonOperator("?|"); }
        | "?&" { result = new JsonOperator("?&"); }
        | <OP_CONCAT> { result = new JsonOperator("||"); }
        | "-" { result = new JsonOperator("-"); }
        | "-#" { result = new JsonOperator("-#"); }
        | "<->" { result = new GeometryDistance("<->"); }
        | "<#>" { result = new GeometryDistance("<#>"); }
    )

    ( LOOKAHEAD(2) <K_PRIOR> rightExpression=ComparisonItem() { oraclePrior = EqualsTo.ORACLE_PRIOR_END; }
      | rightExpression=ComparisonItem() )

    [ LOOKAHEAD(2) "(" "+" ")" { oracleJoin=EqualsTo.ORACLE_JOIN_LEFT; } ]

    {
         BinaryExpression regCond = (BinaryExpression) result;
        regCond.setLeftExpression(leftExpression);
        regCond.setRightExpression(rightExpression);

        if (oracleJoin>0)
            ((SupportsOldOracleJoinSyntax)result).setOldOracleJoinSyntax(oracleJoin);

        if (oraclePrior!=EqualsTo.NO_ORACLE_PRIOR)
            ((SupportsOldOracleJoinSyntax)result).setOraclePriorPosition(oraclePrior);
    }

    {
        linkAST(result,jjtThis);
        return result;
    }
}

Expression SQLCondition():
{
    Expression result;
    Expression left;
}
{
    (
    result=ExistsExpression()
    | LOOKAHEAD(InExpression()) result=InExpression()
    | left = SimpleExpression() { result = left; }
        [ LOOKAHEAD(2) ((LOOKAHEAD(2) result=Between(left)
         | LOOKAHEAD(IsNullExpression()) result=IsNullExpression(left)
         | LOOKAHEAD(IsBooleanExpression()) result=IsBooleanExpression(left)
         | LOOKAHEAD(2) result=LikeExpression(left)
         | LOOKAHEAD(IsDistinctExpression()) result=IsDistinctExpression(left)
         | result=SimilarToExpression(left)
        )) ]
    )
    { return result; }
}

Expression InExpression() #InExpression :
{
    InExpression result = new InExpression();
    ItemsList leftItemsList = null;
    ExpressionList rightItemsList = null;
    Expression leftExpression = null;
    Expression rightExpression = null;
    Token token;
    MultiExpressionList multiExpressionList = null;
    ExpressionList expressionList = null;
}
{
        leftExpression=SimpleExpression() { result.setLeftExpression(leftExpression); }
        [ "(" "+" ")" { result.setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); } ]

    [<K_NOT> { result.setNot(true); } ] <K_IN>
    (
      LOOKAHEAD(2) token=<S_CHAR_LITERAL> {  result.setRightExpression(new StringValue(token.image)); }
      | LOOKAHEAD(3) rightExpression = Function() {  result.setRightExpression(rightExpression); }
      | LOOKAHEAD( "(" ComplexExpressionList() ")" ) "(" rightItemsList=ComplexExpressionList() { result.setRightItemsList(rightItemsList.withBrackets(true) ); } ")"
      | LOOKAHEAD(3) "(" rightExpression = SubSelect() {  result.setRightExpression( ((SubSelect) rightExpression).withUseBrackets(true) ); } ")"
      | LOOKAHEAD(2) rightExpression = SimpleExpression() {  result.setRightExpression(rightExpression); }
    )
    {
        linkAST(result,jjtThis);
        return result;
    }
}

MultiExpressionList MultiInExpressions():
{
   MultiExpressionList multiExpressionList = null;
   ExpressionList expressionList = null;
}
{
  "(" "("
   expressionList=SimpleExpressionList(true) {
       if(multiExpressionList == null) {
         multiExpressionList = new MultiExpressionList();
       }
       multiExpressionList.addExpressionList(expressionList);
   }
   // potentially additional expression lists
   ( LOOKAHEAD(3)
     ")" "," "(" expressionList=SimpleExpressionList(true)
     {
       if(multiExpressionList == null) {
          multiExpressionList = new MultiExpressionList();
       }
       multiExpressionList.addExpressionList(expressionList);
     }
   )*
   ")" ")"
  {
    return multiExpressionList;
  }
}

Expression Between(Expression leftExpression) :
{
    Between result = new Between();
    Expression betweenExpressionStart = null;
    Expression betweenExpressionEnd = null;
}
{
        [<K_NOT> { result.setNot(true); }]
        <K_BETWEEN> betweenExpressionStart=SimpleExpression() <K_AND> betweenExpressionEnd=SimpleExpression()

    {
        result.setLeftExpression(leftExpression);
        result.setBetweenExpressionStart(betweenExpressionStart);
        result.setBetweenExpressionEnd(betweenExpressionEnd);
        return result;
    }
}

Expression LikeExpression(Expression leftExpression) #LikeExpression:
{
    LikeExpression result = new LikeExpression();
    Expression rightExpression = null;
    Expression escape;
}
{
    [<K_NOT> { result.setNot(true); } ] ( <K_LIKE> | <K_ILIKE> { result.setCaseInsensitive(true); } ) rightExpression=SimpleExpression()
    [<K_ESCAPE> escape=Expression() { result.setEscape(escape); }]
    {
        result.setLeftExpression(leftExpression);
        result.setRightExpression(rightExpression);
        linkAST(result,jjtThis);
        return result;
    }
}

Expression SimilarToExpression(Expression leftExpression) #SimilarToExpression:
{
    SimilarToExpression result = new SimilarToExpression();
    Expression rightExpression = null;
}
{
    [<K_NOT> { result.setNot(true); } ]
    <K_SIMILAR> <K_TO>
    rightExpression=SimpleExpression()
    [<K_ESCAPE> token=<S_CHAR_LITERAL> { result.setEscape((new StringValue(token.image)).getValue()); }]
    {
        result.setLeftExpression(leftExpression);
        result.setRightExpression(rightExpression);
        linkAST(result,jjtThis);
        return result;
    }
}

Expression IsDistinctExpression(Expression leftExpression) #IsDistinctExpression:
{
    IsDistinctExpression result = new IsDistinctExpression();
    Expression rightExpression = null;
}
{
    <K_IS> [<K_NOT> { result.setNot(true); } ] <K_DISTINCT> <K_FROM>
    rightExpression=SimpleExpression()
    {
        result.setLeftExpression(leftExpression);
        result.setRightExpression(rightExpression);
        linkAST(result,jjtThis);
        return result;
    }
}

Expression IsNullExpression(Expression leftExpression):
{
    IsNullExpression result = new IsNullExpression();
}
{
        (<K_ISNULL> { result.setUseIsNull(true); } | <K_IS> [<K_NOT> { result.setNot(true); } ] <K_NULL> )

    {
        result.setLeftExpression(leftExpression);
        return result;
    }
}

Expression IsBooleanExpression(Expression leftExpression):
{
    IsBooleanExpression result = new IsBooleanExpression();
}
{
        (
          <K_IS> [<K_NOT> { result.setNot(true); } ] (<K_TRUE> { result.setIsTrue(true); } | <K_FALSE> { result.setIsTrue(false); })
        )

    {
        result.setLeftExpression(leftExpression);
        return result;
    }
}

Expression ExistsExpression():
{
    ExistsExpression result = new ExistsExpression();
    Expression rightExpression = null;
}
{
    <K_EXISTS> rightExpression=SimpleExpression()
    {
        result.setRightExpression(rightExpression);
        return result;
    }
}

ExpressionList SQLExpressionList():
{
    ExpressionList retval = new ExpressionList();
    List<Expression> expressions = new ArrayList<Expression>();
    Expression expr = null;
}
{
    expr=Expression() { expressions.add(expr); } ("," expr=Expression() { expressions.add(expr); })*
    {
        retval.setExpressions(expressions);
        return retval;
    }
}

ExpressionList SimpleExpressionList(boolean outerBrackets) #ExpressionList:
{
    ExpressionList retval = new ExpressionList().withBrackets(outerBrackets);
    List<Expression> expressions = new ArrayList<Expression>();
    Expression expr = null;
}
{
    expr=SimpleExpression() { expressions.add(expr); } 
    ( LOOKAHEAD(2, {!interrupted} ) "," expr=SimpleExpression() { expressions.add(expr); } )*
    {
        retval.setExpressions(expressions);
        return retval;
    }
}

ExpressionList ComplexExpressionList() #ExpressionList:
{
    ExpressionList retval = new ExpressionList();
    List<Expression> expressions = new ArrayList<Expression>();
    Expression expr = null;
}
{
    (   
        LOOKAHEAD(2) expr=OracleNamedFunctionParameter()
        | expr=Expression() 
    ) { expressions.add(expr); }

    (
        LOOKAHEAD(2, {!interrupted}) ","
        (
            LOOKAHEAD(2) expr=OracleNamedFunctionParameter()
            | expr=Expression() 
        ) { expressions.add(expr); }
    )*

    {
        retval.setExpressions(expressions);
        return retval;
    }
}

// trim( [leading|trailing|both] expr from expr)
// The [leading|trailing|both] token has already been consumed
NamedExpressionList NamedExpressionList1():
{
    NamedExpressionList retval = new NamedExpressionList();
    List<Expression> expressions = new ArrayList<Expression>();
    List<String> names = new ArrayList<String>();
    Expression expr1 = null;
    Expression expr2 = null;
	String name = "";
    Token tk1 = null;
    Token tk2 = null;
}
{
    (
		(tk1=<K_BOTH>|tk1=<K_LEADING>|tk1=<K_TRAILING>) { names.add(tk1.image); }
		expr1=SimpleExpression()
		(tk2=<K_FROM>|tk2=<K_IN>|tk2=<K_PLACING>)
		expr2=SimpleExpression()
		{ expressions.add(expr1); names.add(tk2.image); expressions.add(expr2);}
    )

    {
        retval.setNames(names);
        retval.setExpressions(expressions);
        return retval;
    }
}

// substring(expr1 from expr2)
// substring(expr1 from expr2 for expr3)
// trim(expr1 from expr2)
// position(expr1 in expr2)
// overlay(expr1 placing expr2 from expr3)
// overlay(expr1 placing expr2 from expr3 for expr4)
// expr1 has already been consumed
NamedExpressionList NamedExpressionListExprFirst():
{
    NamedExpressionList retval = new NamedExpressionList();
    List<Expression> expressions = new ArrayList<Expression>();
    List<String> names = new ArrayList<String>();
    Expression expr1 = null;
    Expression expr2 = null;
    Expression expr3 = null;
    Expression expr4 = null;
    Token tk2 = null;
    Token tk3 = null;
    Token tk4 = null;
}
{
	expr1=SimpleExpression()
	(tk2=<K_FROM>|tk2=<K_IN>|tk2=<K_PLACING>)
	{
		names.add("");
		expressions.add(expr1);
		names.add(tk2.image);
	}
    (
        expr2=SimpleExpression() { expressions.add(expr2);}
		(
			(tk3=<K_FOR>|tk3=<K_FROM>)
			expr3=SimpleExpression() {names.add(tk3.image); expressions.add(expr3);}
			(
				(tk4=<K_FOR>)
				expr4=SimpleExpression() {names.add(tk4.image); expressions.add(expr4);}
			)?
		)?
    )

    {
        retval.setNames(names);
        retval.setExpressions(expressions);
        return retval;
    }
}


ExpressionList SimpleExpressionListAtLeastTwoItems():
{
    ExpressionList retval = new ExpressionList();
    List<Expression> expressions = new ArrayList<Expression>();
    Expression expr = null;
}
{
    expr=SimpleExpression() { expressions.add(expr); } ("," expr=SimpleExpression() { expressions.add(expr); })+
    {
        retval.setExpressions(expressions);
        return retval;
    }
}

Expression ComparisonItem() :
{
    Expression retval = null;
}
{
  (
    LOOKAHEAD(3) retval=AnyComparisonExpression()
    | LOOKAHEAD(ValueListExpression()) retval=ValueListExpression()
    | LOOKAHEAD(3) retval=SimpleExpression()
    | retval=RowConstructor()
  )

   {
      return retval;
   }
}

Expression AnyComparisonExpression() :
{
    AnyComparisonExpression anyComparisonExpr = null;
    AnyType anyType;
    SubSelect subSelect;
    ItemsList simpleExpressionList;
}
{
 (<K_ANY> { anyType = AnyType.ANY; } | <K_SOME> { anyType = AnyType.SOME; } | <K_ALL> { anyType = AnyType.ALL; } )
    "("

    // if the next block looks alike an ExpressionList without Brackets, then parse as List
    (
        LOOKAHEAD( <K_VALUES> SimpleExpressionList(false) )
        (
            <K_VALUES>
            simpleExpressionList = SimpleExpressionList(false) { anyComparisonExpr=new AnyComparisonExpression(anyType, simpleExpressionList).withUseBracketsForValues(false); }
        )
         // Otherwise parse it as a SubSelect
        | subSelect = SubSelect() { anyComparisonExpr=new AnyComparisonExpression(anyType, subSelect.withUseBrackets(false)).withUseBracketsForValues(false); }
            
    )
    ")"
    {
      return anyComparisonExpr;
    }
}

Expression SimpleExpression():
{
    Expression retval = null;
    UserVariable user = null;
    Token operation = null;
}
{
    [ LOOKAHEAD(UserVariable() ("=" | ":=") ) 
        user = UserVariable() 
       ( operation = "=" | operation = ":=" )
    ]
    retval=ConcatExpression()
    {
        if (user != null) {
            VariableAssignment assignment = new VariableAssignment();
            assignment.setVariable(user);
            assignment.setOperation(operation.image);
            assignment.setExpression(retval);
            return assignment;
        } else 
            return retval;
    }
}

Expression ConcatExpression():
{
    Expression result = null;
    Expression leftExpression = null;
    Expression rightExpression = null;
}
{
    leftExpression=BitwiseAndOr()  { result = leftExpression; }
    (LOOKAHEAD(3)
        <OP_CONCAT>  /* Oracle allows space between the bars. */
        rightExpression=BitwiseAndOr()
        {
            Concat binExp = new Concat();
            binExp.setLeftExpression(leftExpression);
            binExp.setRightExpression(rightExpression);
            result = binExp;
            leftExpression = result;
        }
    )*

    { return result; }
}

Expression BitwiseAndOr():
{
    Expression result = null;
    Expression leftExpression = null;
    Expression rightExpression = null;
}
{
    leftExpression=AdditiveExpression()  { result = leftExpression; }
    (
        (
            "|" { result = new BitwiseOr(); }
            |
            "&" { result = new BitwiseAnd(); }
			|
			"<<" { result = new BitwiseLeftShift(); }
			|
			">>" { result = new BitwiseRightShift(); }
        )

        rightExpression=AdditiveExpression()

        {
             BinaryExpression binExp = (BinaryExpression) result;
            binExp.setLeftExpression(leftExpression);
            binExp.setRightExpression(rightExpression);
            leftExpression = result;
        }
    )*

    { return result; }
}

Expression AdditiveExpression():
{
    Expression result = null;
    Expression leftExpression = null;
    Expression rightExpression = null;
}
{
    leftExpression=MultiplicativeExpression()  { result = leftExpression; }
    ( LOOKAHEAD(2)
        ("+" { result = new Addition(); }
                                    | "-" { result = new Subtraction(); } )

        rightExpression=MultiplicativeExpression()
        {
             BinaryExpression binExp = (BinaryExpression) result;
            binExp.setLeftExpression(leftExpression);
            binExp.setRightExpression(rightExpression);
            leftExpression = result;
        }
    )*

    { return result; }
}

Expression MultiplicativeExpression():
{
    Expression result = null;
    Expression leftExpression = null;
    Expression rightExpression = null;
}
{
    (
      leftExpression=BitwiseXor()
    )
      { result = leftExpression; }
    (
        LOOKAHEAD(2) ("*" { result = new Multiplication(); }
                                    | "/" { result = new Division(); }
                                    | <K_DIV> { result = new IntegerDivision(); }
                                    | "%" { result = new Modulo(); }
                    )

        rightExpression=BitwiseXor()

        {
             BinaryExpression binExp = (BinaryExpression) result;
            binExp.setLeftExpression(leftExpression);
            binExp.setRightExpression(rightExpression);
            leftExpression = result;
        }
    )*
    { return result; }
}

Expression BitwiseXor():
{
    Expression result = null;
    Expression leftExpression = null;
    Expression rightExpression = null;
}
{
    leftExpression=PrimaryExpression()  { result = leftExpression; }
    (
        "^"
        rightExpression=PrimaryExpression()
        {
            BitwiseXor binExp = new BitwiseXor();
            binExp.setLeftExpression(leftExpression);
            binExp.setRightExpression(rightExpression);
            result = binExp;
            leftExpression = result;
        }
    )*

    { return result; }
}

Expression ArrayExpression(Expression obj): {
    Expression idxExpr = null;
    Expression startExpr = null;
    Expression stopExpr = null;
} {
    "["
        [LOOKAHEAD(3) idxExpr = SimpleExpression()]
        [
          (":" { startExpr=idxExpr; idxExpr=null; })
          [stopExpr = SimpleExpression()]
        ]
    "]"
    { return new ArrayExpression(obj, idxExpr, startExpr, stopExpr); }
}

Expression PrimaryExpression() #PrimaryExpression:
{
    Expression retval = null;
    CastExpression castExpr = null;
    TimezoneExpression timezoneExpr = null;
    Expression timezoneRightExpr = null;
    Token token = null;
    Token sign = null;
    String tmp = "";
    ColDataType type = null;
    boolean not = false;
    boolean exclamationMarkNot = false;
    boolean dateExpressionAllowed = true;
    ExpressionList list;
}
{
    [ <K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; } ]
    [sign="+" | sign="-" | sign="~"]
    (
        <K_NULL> { retval = new NullValue(); }

        | LOOKAHEAD(3, {!interrupted}) retval=CaseWhenExpression()

        | retval = SimpleJdbcParameter()

        | LOOKAHEAD(2, {!interrupted}) retval=JdbcNamedParameter()

        | retval=UserVariable()

        | LOOKAHEAD(2, {!interrupted}) retval=NumericBind()

        | LOOKAHEAD(3, {!interrupted}) retval=ExtractExpression()

        | retval=MySQLGroupConcat()

        | retval=XMLSerializeExpr()

        | LOOKAHEAD(JsonExpression(), {!interrupted}) retval=JsonExpression()

        | LOOKAHEAD(JsonFunction(), {!interrupted}) retval = JsonFunction()

        | LOOKAHEAD(JsonAggregateFunction(), {!interrupted}) retval = JsonAggregateFunction()

        /* | LOOKAHEAD(FunctionWithCondParams()) retval = FunctionWithCondParams() */

        | LOOKAHEAD(FullTextSearch(), {!interrupted}) retval = FullTextSearch()

        | LOOKAHEAD(Function(), {!interrupted}) retval=Function() [ LOOKAHEAD(2) retval = AnalyticExpression( (Function) retval ) ]

        | LOOKAHEAD(2, {!interrupted}) retval = IntervalExpression() { dateExpressionAllowed = false; }

        | token=<S_DOUBLE>  { retval = new DoubleValue(token.image); }

        | token=<S_LONG> { retval = new LongValue(token.image); }

        | token=<S_HEX>  { retval = new HexValue(token.image); }

        | LOOKAHEAD(2, {!interrupted}) retval=CastExpression()

        | LOOKAHEAD(2, {!interrupted}) retval=TryCastExpression()

        //| LOOKAHEAD(2) retval=RowConstructor()

        // support timestamp expressions
        | (token=<K_TIME_KEY_EXPR> | token=<K_CURRENT>) { retval = new TimeKeyExpression(token.image); }

        | LOOKAHEAD(2, {!interrupted}) retval=DateTimeLiteralExpression()

        | LOOKAHEAD(2, {!interrupted}) <K_ARRAY_LITERAL> retval=ArrayConstructor(true)

        | LOOKAHEAD(2, {!interrupted}) retval = NextValExpression()

        | retval=ConnectByRootOperator()

        | LOOKAHEAD(2, {!interrupted}) <K_ALL> { retval = new AllValue(); }

        | LOOKAHEAD(2, {!interrupted}) retval=Column()

        | token=<S_CHAR_LITERAL> { retval = new StringValue(token.image); linkAST(retval,jjtThis); }

        | "{d" token=<S_CHAR_LITERAL> "}"  { retval = new DateValue(token.image); }

        | "{t" token=<S_CHAR_LITERAL> "}"  { retval = new TimeValue(token.image); }

        | "{ts" token=<S_CHAR_LITERAL> "}" { retval = new TimestampValue(token.image); }

        | LOOKAHEAD("(" retval=SubSelect() ")", {!interrupted} ) "(" retval=SubSelect() ")"

        | (
             "(" ( LOOKAHEAD( { getAsBoolean(Feature.allowComplexParsing) && !interrupted } ) list = ComplexExpressionList() |  list = SimpleExpressionList(true) ) ")"
              {
                  if (list.getExpressions().size() == 1) {
                      retval = new Parenthesis(list.getExpressions().get(0));
                  } else {
                      retval = new RowConstructor().withExprList(list);
                  }
              }
           ["." tmp=RelObjectNameExt() { retval = new RowGetExpression(retval, tmp); }]
        )
    )

    [
        <K_COLLATE> token=<S_IDENTIFIER> { retval = new CollateExpression(retval, token.image); }
    ]

    [
        LOOKAHEAD(2, { dateExpressionAllowed } ) retval = IntervalExpressionWithoutInterval(retval)
    ]

    [ retval = ArrayExpression(retval) ]

    ( "::" type=ColDataType() {
        castExpr = new CastExpression();
        castExpr.setUseCastKeyword(false);
        castExpr.setLeftExpression(retval);
        castExpr.setType(type);
        retval=castExpr;
    } )*

    ( LOOKAHEAD(2) <K_AT> <K_DATETIMELITERAL> <K_ZONE> timezoneRightExpr=PrimaryExpression() {
        if (timezoneExpr == null)
            timezoneExpr = new TimezoneExpression();

        timezoneExpr.addTimezoneExpression(timezoneRightExpr);
    } )*

    {
        if (timezoneExpr != null && !timezoneExpr.getTimezoneExpressions().isEmpty()) {
            timezoneExpr.setLeftExpression(retval);
            retval=timezoneExpr;
        }
    }

    {
        if (sign != null) {
            retval = new SignedExpression(sign.image.charAt(0), retval);
        }
        if (not) {
            retval = new NotExpression(retval, exclamationMarkNot);
        }
        return retval;
    }
}

ConnectByRootOperator ConnectByRootOperator() #ConnectByRootOperator: {
    Column column;
}
{
    <K_CONNECT_BY_ROOT> column = Column()
    {
      return new ConnectByRootOperator(column);
    }
}

NextValExpression NextValExpression() : {
    List<String> data = new ArrayList<String>();
    Token token;
}
{
     token=<K_NEXTVAL>  data = RelObjectNameList()
    {
        return new NextValExpression(data, token.image);
    }
}

JdbcNamedParameter JdbcNamedParameter() : {
    JdbcNamedParameter parameter = new JdbcNamedParameter();
    String name;
}
{
    ":" (name=RelObjectNameExt2() { parameter.setName(name); })
    {
        return parameter;
    }
}

OracleNamedFunctionParameter OracleNamedFunctionParameter() : {
    String name;
    Expression expression;
}
{
    name=RelObjectNameExt2()
    <K_ORACLE_NAMED_PARAMETER_ASSIGNMENT>
    expression=Expression() 
    {
        return new OracleNamedFunctionParameter(name, expression);
    }
}

UserVariable UserVariable() : {
    UserVariable var = new UserVariable();
    String varName;
    String var2;
}
{
    ("@" | "@@" { var.setDoubleAdd(true);} )
    varName=RelObjectNameExt2()
    ( "." var2=RelObjectNameExt2() { varName+="." + var2; } )*
    {
        var.setName(varName);
        return var;
    }
}

NumericBind NumericBind() : {
    NumericBind var = new NumericBind();
    Token token;
}
{
    ":" token=<S_LONG>
    {
        var.setBindId(Integer.valueOf(token.image));
        return var;
    }
}

DateTimeLiteralExpression DateTimeLiteralExpression() : {
    DateTimeLiteralExpression expr = new DateTimeLiteralExpression();
    Token t;
} {
    t=<K_DATETIMELITERAL>  { expr.setType(DateTimeLiteralExpression.DateTime.valueOf(t.image.toUpperCase())); }

    t=<S_CHAR_LITERAL> { expr.setValue(t.image); return expr; }
}

ArrayConstructor ArrayConstructor(final boolean arrayKeyword) : {
    ArrayList<Expression> expList = new ArrayList();
    ArrayConstructor array = new ArrayConstructor(expList, arrayKeyword);
    Expression exp = null;
} {
    "["
        [ (LOOKAHEAD(3) exp = SimpleExpression() | exp = ArrayConstructor(false))
          { expList.add(exp); }
        ("," (exp = SimpleExpression() | exp = ArrayConstructor(false))
            { expList.add(exp); })*
        ]
    "]"
    { return array; }
}

JsonExpression JsonExpression() : {
  JsonExpression result = new JsonExpression();
  Expression expr;
  Token token;
  ColDataType type = null;
  CastExpression castExpr = null;
}
{
    expr=Column()
    ( "::" type=ColDataType() {
            castExpr = new CastExpression();
            castExpr.setUseCastKeyword(false);
            castExpr.setLeftExpression(expr);
            castExpr.setType(type);
            expr=castExpr;
    } )*
    (
        "->" (token=<S_CHAR_LITERAL> | token=<S_LONG>) {result.addIdent(token.image,"->");} |
        "->>" (token=<S_CHAR_LITERAL> | token=<S_LONG>) {result.addIdent(token.image,"->>");} |
        "#>" token=<S_CHAR_LITERAL> {result.addIdent(token.image,"#>");} |
        "#>>" token=<S_CHAR_LITERAL> {result.addIdent(token.image,"#>>");}
    )+
    {
        result.setExpression(expr);
        return result;
    }
}

JsonFunction JsonFunction() : {
    JsonFunction result = new JsonFunction();
    boolean usingKeyKeyword = false;
    boolean usingValueKeyword = false;
    boolean usingFormatJason = false;
    Token keyToken;
    Token valueToken = null;
    Column column = null;
    JsonKeyValuePair keyValuePair;

    Expression expression = null;
    JsonFunctionExpression functionExpression;
  
}
{
    (
        ( 
          ( <K_JSON_OBJECT> 
            "(" { result.setType( JsonFunctionType.OBJECT ); }
                (
                    (
                        // SQL2016 compliant Syntax
                        (
                            [   "KEY" { usingKeyKeyword = true; } ]
                            keyToken = <S_CHAR_LITERAL>

                             ( LOOKAHEAD(2)
                                ( ":" |  "," { result.setType( JsonFunctionType.POSTGRES_OBJECT ); } | "VALUE" { usingValueKeyword = true; } )
                                (
                                    expression = Expression()
                                )
                                [ <K_FORMAT> <K_JSON> { usingFormatJason = true; } ]
                            )? {
                                   if (expression !=null) {
                                                                           keyValuePair = new JsonKeyValuePair( keyToken.image, expression, usingKeyKeyword, usingValueKeyword );
                                                                           keyValuePair.setUsingFormatJson( usingFormatJason );
                                                                           result.add(keyValuePair);
                                                                      } else {
                                       result.setType( JsonFunctionType.POSTGRES_OBJECT );
                                       keyValuePair = new JsonKeyValuePair( keyToken.image, null, false, false );
                                       result.add(keyValuePair);
                                  }
                               }

                            // --- Next Elements
                            (   ","  { usingKeyKeyword = false; usingValueKeyword = false;  }
                                [   "KEY" { usingKeyKeyword = true; } ]
                                keyToken = <S_CHAR_LITERAL>
                                ( ":" | ","  { result.setType( JsonFunctionType.MYSQL_OBJECT ); } | "VALUE" { usingValueKeyword = true; } )
                                (
                                    expression = Expression() { keyValuePair = new JsonKeyValuePair( keyToken.image, expression, usingKeyKeyword, usingValueKeyword ); result.add(keyValuePair); }
                                )
                                [ <K_FORMAT> <K_JSON> { keyValuePair.setUsingFormatJson( true ); } ]
                            )*
                        )
                    )?

                    [
                      (
                          <K_NULL> <K_ON> <K_NULL>  { result.setOnNullType(  JsonAggregateOnNullType.NULL ); }
                      )
                      |
                      (
                          <K_ABSENT> <K_ON> <K_NULL> { result.setOnNullType(  JsonAggregateOnNullType.ABSENT ); }
                      )
                    ]

                    [
                      (
                          <K_WITH> <K_UNIQUE> <K_KEYS> { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITH ); }
                      )
                      |
                      (
                          <K_WITHOUT> <K_UNIQUE> <K_KEYS> { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITHOUT ); }
                      )
                    ]
                )
            ")"
          )
          |
          ( 
            <K_JSON_ARRAY> { result.setType( JsonFunctionType.ARRAY ); } 
            "(" 
                (   
                    LOOKAHEAD(2) ( 
                        <K_NULL> <K_ON> <K_NULL>  { result.setOnNullType(  JsonAggregateOnNullType.NULL ); }
                    )
                    |
                    expression=Expression() { functionExpression = new JsonFunctionExpression( expression ); result.add( functionExpression ); }
                    
                    [ LOOKAHEAD(2) <K_FORMAT> <K_JSON> { functionExpression.setUsingFormatJson( true ); } ]
                    (   
                        ","
                        expression=Expression() { functionExpression = new JsonFunctionExpression( expression ); result.add( functionExpression ); }
                        [ LOOKAHEAD(2) <K_FORMAT> <K_JSON> { functionExpression.setUsingFormatJson( true ); } ]
                    )*
                )*

                [ 
                  <K_ABSENT> <K_ON> <K_NULL> { result.setOnNullType(  JsonAggregateOnNullType.ABSENT ); }
                ]

            ")"
          )
        )
    )

    {
        return result;
    }
}

JsonAggregateFunction JsonAggregateFunction() : {
    JsonAggregateFunction result = new JsonAggregateFunction();
    Token token;
    Expression expression;
    List<OrderByElement> expressionOrderByList = null;
  
    Expression filter;
    ExpressionList expressionList = null;
    List<OrderByElement> olist = null;
    WindowElement windowElement = null;
    boolean partitionByBrackets = false;
}
{
    (
        ( 
          ( <K_JSON_OBJECTAGG> 
            "(" { result.setType( JsonFunctionType.OBJECT ); } 
            [ "KEY" { result.setUsingKeyKeyword( true ); } ]
            ( token = <DT_ZONE> | token = <S_DOUBLE> | token = <S_LONG> | token = <S_HEX> | token = <S_CHAR_LITERAL> | token = <S_IDENTIFIER> | token = <S_QUOTED_IDENTIFIER> ) { result.setKey( token.image ); }
            ( ":" | "VALUE" {result.setUsingValueKeyword( true ); } ) 
            ( token = <S_IDENTIFIER> | token = <S_QUOTED_IDENTIFIER> ) { result.setValue( token.image ); }

            [ <K_FORMAT> <K_JSON> { result.setUsingFormatJson( true ); } ]

            [ 
              LOOKAHEAD(2) ( 
                  <K_NULL> <K_ON> <K_NULL>  { result.setOnNullType(  JsonAggregateOnNullType.NULL ); }
              )
              |
              ( 
                  <K_ABSENT> <K_ON> <K_NULL> { result.setOnNullType(  JsonAggregateOnNullType.ABSENT ); }
              )
            ]

            [
              (
                  <K_WITH> <K_UNIQUE> <K_KEYS> { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITH ); }
              )
              |
              (
                  <K_WITHOUT> <K_UNIQUE> <K_KEYS> { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITHOUT ); }
              )
            ]
            ")"
          )
          |
          ( 
            <K_JSON_ARRAYAGG>
            "(" { result.setType( JsonFunctionType.ARRAY ); } 
            expression=Expression() { result.setExpression( expression ); }
            [ <K_FORMAT> <K_JSON> { result.setUsingFormatJson( true ); } ]
            [ expressionOrderByList = OrderByElements() { result.setExpressionOrderByElements( expressionOrderByList ); } ]

            [ 
              LOOKAHEAD(2) ( 
                  <K_NULL> <K_ON> <K_NULL>  { result.setOnNullType(  JsonAggregateOnNullType.NULL ); }
              )
              |
              ( 
                  <K_ABSENT> <K_ON> <K_NULL> { result.setOnNullType(  JsonAggregateOnNullType.ABSENT ); }
              )
            ]

            ")"
          )
        )

        // -- Filter
        [ LOOKAHEAD(2) <K_FILTER> "(" <K_WHERE> { result.setAnalyticType(AnalyticType.FILTER_ONLY); } filter = Expression() { result.setFilterExpression( filter ); } ")"  ]

        // -- OVER
        [   LOOKAHEAD(2)
            <K_OVER> {result.setAnalyticType(AnalyticType.OVER);}
            "("
            [<K_PARTITION> <K_BY>
                (LOOKAHEAD(ComplexExpressionList()) expressionList=ComplexExpressionList()
                | "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")" )
            ]
            [olist=OrderByElements() ]
            [windowElement = WindowElement() ]
            {
                result.setPartitionExpressionList(expressionList, partitionByBrackets);
                result.setOrderByElements(olist);
                result.setWindowElement(windowElement);
            }
            ")"
        ]
    )

    {
        return result;
    }
}

IntervalExpression IntervalExpression() : {
    IntervalExpression interval;
    Token token = null;
    Expression expr = null;
    boolean signed = false;
}
{

{ interval = new IntervalExpression(); }
    <K_INTERVAL> ["-" {signed=true;}] (token=<S_LONG> | token=<S_DOUBLE> | token=<S_CHAR_LITERAL> | LOOKAHEAD(SimpleJdbcParameter()) expr = SimpleJdbcParameter() | expr = JdbcNamedParameter() | LOOKAHEAD(Function()) expr = Function() | expr = Column())
    {
        if (expr != null) {
            if (signed) expr = new SignedExpression('-', expr);
            interval.setExpression(expr);
        } else {
            interval.setParameter((signed?"-":"") + token.image);
        }
    }
    [ LOOKAHEAD(2) (token = <S_IDENTIFIER> | token = <K_DATE_LITERAL>) { interval.setIntervalType(token.image); } ]
    {
        return interval;
    }
}

IntervalExpression IntervalExpressionWithoutInterval(Expression expr) : {
    IntervalExpression interval;
    Token token;
    boolean signed = false;
}
{
    {
        interval = new IntervalExpression(false);
        interval.setExpression(expr);
    }
    token = <K_DATE_LITERAL> { interval.setIntervalType(token.image); }
    {
        return interval;
    }
}

KeepExpression KeepExpression() : {
    KeepExpression keep = new KeepExpression();
    Token token;
    List<OrderByElement> list;
}
{
    <K_KEEP> "(" token = <S_IDENTIFIER> (<K_FIRST> { keep.setFirst(true); } | <K_LAST> { keep.setFirst(false); })
      list = OrderByElements() ")"

    {
        keep.setName(token.image);
        keep.setOrderByElements(list);
        return keep;
    }
}


void windowFun(AnalyticExpression retval):{
         String windowName = null;
         WindowDefinition winDef;
} {
    ([<K_IGNORE> <K_NULLS> { retval.setIgnoreNullsOutside(true); } ] <K_OVER> {retval.setType(AnalyticType.OVER);}
        | <K_WITHIN> <K_GROUP> {retval.setType(AnalyticType.WITHIN_GROUP);} )

    (
        windowName = RelObjectName() { retval.setWindowName(windowName); }
    |    
        winDef = windowDefinition() { retval.setWindowDefinition(winDef); }
    )
}

WindowDefinition windowDefinition() : {
    ExpressionList expressionList = null;
    List<OrderByElement> olist = null;
    WindowElement windowElement = null;
    boolean partitionByBrackets = false;
    WindowDefinition winDef = new WindowDefinition();
} {
    "("
    [<K_PARTITION> <K_BY>
        (LOOKAHEAD(ComplexExpressionList()) expressionList=ComplexExpressionList()
        | "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")" )
    ]
    [olist=OrderByElements() ]
    [windowElement = WindowElement() ]
    {
        winDef.setPartitionExpressionList(expressionList, partitionByBrackets);
        winDef.setOrderByElements(olist);
        winDef.setWindowElement(windowElement);
    }
    ")"
    { return winDef; }
}

AnalyticExpression AnalyticExpression(Function function) :
{
    AnalyticExpression retval = new AnalyticExpression(function);
    Expression filter = null;
}
{
    ((<K_FILTER> "(" <K_WHERE> {retval.setType(AnalyticType.FILTER_ONLY);} filter = Expression() ")" [ LOOKAHEAD(2) windowFun(retval) ] )
        | windowFun(retval))
    {
        retval.setFilterExpression(filter);
        return retval;
    }
}

WindowElement WindowElement():
{
    WindowElement windowElement = new WindowElement();
    WindowRange range = new WindowRange();
    WindowOffset offset = null;
}
{
    (<K_ROWS> { windowElement.setType(WindowElement.Type.ROWS); }  |  <K_RANGE> { windowElement.setType(WindowElement.Type.RANGE); } )
    ( (
      <K_BETWEEN> { windowElement.setRange(range); }
      offset = WindowOffset() { range.setStart(offset); }
      <K_AND> offset = WindowOffset() { range.setEnd(offset); }
      )
    |
      offset = WindowOffset() { windowElement.setOffset(offset); }
    )

    {
        return windowElement;
    }
}

WindowOffset WindowOffset():
{
    WindowOffset offset = new WindowOffset();
    Expression expr = null;
}
{
    (
		(
			<K_UNBOUNDED> (<K_PRECEDING> { offset.setType(WindowOffset.Type.PRECEDING); } |
											<K_FOLLOWING> { offset.setType(WindowOffset.Type.FOLLOWING); } )
		)
		|
		LOOKAHEAD(2) ( <K_CURRENT> <K_ROW> { offset.setType(WindowOffset.Type.CURRENT); } )
		|
		( expr = SimpleExpression() {
			offset.setType(WindowOffset.Type.EXPR);
			offset.setExpression(expr);
			}
			(<K_PRECEDING> { offset.setType(WindowOffset.Type.PRECEDING); } | <K_FOLLOWING> { offset.setType(WindowOffset.Type.FOLLOWING);  } )
		)
	)

    {
        return offset;
    }
}

ExtractExpression ExtractExpression() :
{
    ExtractExpression retval = new ExtractExpression();
    String fieldName = null;
    Token token = null;
    Expression expr = null;
}
{
    <K_EXTRACT>
    "("
        ( fieldName=RelObjectName() { retval.setName(fieldName); } | token=<S_CHAR_LITERAL> { retval.setName(token.image); } )
        <K_FROM>
        expr=SimpleExpression() { retval.setExpression(expr); }
    ")"
    {
        return retval;
    }
}

CastExpression CastExpression():
{
    CastExpression retval = new CastExpression();
    ColDataType type = null;
    RowConstructor rowConstructor = null;
    Expression expression = null;
    boolean    useCastKeyword;
}
{
    <K_CAST> 
    "(" 
    expression=SimpleExpression() 
    <K_AS> { retval.setUseCastKeyword(true); } 
    ( 
        LOOKAHEAD(3) rowConstructor = RowConstructor() { retval.setRowConstructor(rowConstructor); } 
        | type=ColDataType() { retval.setType(type); } 
    )
    ")" 

    {
        retval.setLeftExpression(expression);
        return retval;
    }
}

TryCastExpression TryCastExpression():
{
    TryCastExpression retval = new TryCastExpression();
    ColDataType type = null;
    RowConstructor rowConstructor = null;
    Expression expression = null;
    boolean    useCastKeyword;
}
{
    <K_TRY_CAST>
    "("
    expression=SimpleExpression()
    <K_AS> { retval.setUseCastKeyword(true); }
    (
        LOOKAHEAD(3) rowConstructor = RowConstructor() { retval.setRowConstructor(rowConstructor); }
        | type=ColDataType() { retval.setType(type); }
    )
    ")"

    {
        retval.setLeftExpression(expression);
        return retval;
    }
}

Expression CaseWhenExpression() #CaseWhenExpression:
{
    CaseExpression caseExp = new CaseExpression();
    Expression switchExp = null;
    WhenClause clause;
    List<WhenClause> whenClauses = new ArrayList<WhenClause>();
    Expression elseExp = null;
}
{
    <K_CASE> { caseCounter++; }
    [ switchExp=Expression() ]
    ( clause=WhenThenSearchCondition() { whenClauses.add(clause); } )+
    [<K_ELSE> (LOOKAHEAD( ["("] CaseWhenExpression() [")"] ( <K_WHEN> | <K_ELSE> | <K_END> ) ) ["("] elseExp=CaseWhenExpression() [")" { ((CaseExpression) elseExp).setUsingBrackets(true); } ] 
              | elseExp=Expression()
              )
    ]
    <K_END>  { caseCounter--; }
    {
        caseExp.setSwitchExpression(switchExp);
        caseExp.setWhenClauses(whenClauses);
        caseExp.setElseExpression(elseExp);
        return caseExp;
    }
}

WhenClause WhenThenSearchCondition():
{
    WhenClause whenThen = new WhenClause();
    Expression whenExp = null;
    Expression thenExp = null;
}
{
    <K_WHEN> whenExp=Expression()
    <K_THEN> (
                LOOKAHEAD( ["("] CaseWhenExpression() [")"] ( <K_WHEN> | <K_ELSE> | <K_END> ) ) ["("] thenExp=CaseWhenExpression() [")" { ((CaseExpression) thenExp).setUsingBrackets(true); }]
                | 
                thenExp=Expression()
              )
    {
       whenThen.setWhenExpression(whenExp);
       whenThen.setThenExpression(thenExp);
       return whenThen;
    }
}

RowConstructor RowConstructor(): {
    RowConstructor rowConstructor = new RowConstructor();
    ColumnDefinition columnDefinition = null;
} {
    [ <K_ROW> { rowConstructor.setName("ROW");} ]
    "("
     columnDefinition = ColumnDefinition() { rowConstructor.addColumnDefinition(columnDefinition); }
     (
         "," 
         columnDefinition = ColumnDefinition() { rowConstructor.addColumnDefinition(columnDefinition); }
     )*  
     ")"
            

    {
        return rowConstructor;
    }
}

/**
TODO: VariableExpression should be a standalone class with more operations available. 
*/
EqualsTo VariableExpression(): {
    Expression left;
    Expression right;
} {
    left = UserVariable() "=" right = SimpleExpression()
    {
        EqualsTo equals = new EqualsTo();
        equals.setLeftExpression(left);
        equals.setRightExpression(right);
        return equals;
    }
}

Execute Execute(): {
    List<String> funcName;
    ExpressionList expressionList = null;
    Execute execute = new Execute();
    List<Expression> namedExprList;
    Expression expr;
}
{
    (<K_EXEC> { execute.setExecType(Execute.ExecType.EXEC); }
        | <K_EXECUTE> { execute.setExecType(Execute.ExecType.EXECUTE); }
        | <K_CALL> { execute.setExecType(Execute.ExecType.CALL); } )

    funcName=RelObjectNameList() { execute.setName(funcName); }

    (
        LOOKAHEAD(3) ( expr = VariableExpression() { namedExprList = new ArrayList<Expression>(); namedExprList.add( expr ); }
                ( "," expr = VariableExpression() { namedExprList.add(expr); })*
                { expressionList = new ExpressionList(namedExprList); } )
        |
        LOOKAHEAD(3) expressionList=SimpleExpressionList(true)
        |
        ("(" expressionList=SimpleExpressionList(true) ")" { execute.setParenthesis(true); })
    )?

    {
        execute.setExprList(expressionList);
        return execute;
    }
}

FullTextSearch FullTextSearch() : {
    Column col;
    Token searchModifier;
    Token againstValue;
    JdbcParameter jdbcParameter;
    JdbcNamedParameter jdbcNamedParameter;
    FullTextSearch fs = new FullTextSearch();
    List<Column> matchedColumns = new ArrayList<Column>();
    List<Expression> expList = new ArrayList<Expression>();
}
{
    <K_MATCH> "(" col=Column() { matchedColumns.add(col); } ("," col=Column() { matchedColumns.add(col); } )* ")" <K_AGAINST>
    "(" 
    ( 
      againstValue=<S_CHAR_LITERAL> { fs.setAgainstValue(new StringValue(againstValue.image)); } 
      |  
      jdbcParameter=SimpleJdbcParameter() { fs.setAgainstValue(  jdbcParameter ); }
      |  
      jdbcNamedParameter=SimpleJdbcNamedParameter() { fs.setAgainstValue(  jdbcNamedParameter ); }
    )
    [
        (
            searchModifier="IN NATURAL LANGUAGE MODE"
            | searchModifier="IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION"
            | searchModifier="IN BOOLEAN MODE"
            | searchModifier="WITH QUERY EXPANSION"
        )
        { fs.setSearchModifier(searchModifier.image); }
    ]
    ")"
    {
        fs.setMatchColumns(matchedColumns);
        return fs;
    }
}

Function Function() #Function:
{
    Function retval = new Function();
}
{
    (
        "{" <K_FN> { retval.setEscaped(true); }  InternalFunction(retval) "}"
        | LOOKAHEAD(3) retval = SpecialStringFunctionWithNamedParameters()
        | InternalFunction(retval)
    )
    {
        linkAST(retval,jjtThis);
        return retval;
    }
}

Function SpecialStringFunctionWithNamedParameters() :
{
    Token funcName;
    NamedExpressionList namedExpressionList = null;
    ExpressionList expressionList = null;
    List<OrderByElement> orderByList;
}
{
        funcName = <K_STRING_FUNCTION_NAME> 

        "(" 
        (
            LOOKAHEAD(NamedExpressionList1()) namedExpressionList=NamedExpressionList1()
            |
            LOOKAHEAD(NamedExpressionListExprFirst(), { getAsBoolean(Feature.allowComplexParsing) }) namedExpressionList = NamedExpressionListExprFirst()
            |
            LOOKAHEAD(3, { getAsBoolean(Feature.allowComplexParsing) }) expressionList=ComplexExpressionList() {expressionList.setUsingBrackets(false);}
            |
            LOOKAHEAD(3) expressionList=SimpleExpressionList(false) 
        )
        ")"

    {
        return new Function().withName(funcName.image).withNamedParameters(namedExpressionList).withParameters(expressionList);
    }
}

Function InternalFunction(Function retval) :
{
    List<String> funcName;
    String tmp = null;
    List<Expression> expressions = new ArrayList<Expression>();
    ExpressionList expressionList = null;
    NamedExpressionList namedExpressionList = null;
    KeepExpression keep = null;
    SubSelect expr = null;
    Token tk1 = null;
    Token tk2 = null;
    Expression expr1 = null;
    List<OrderByElement> orderByList;
    boolean ignoreNulls = false;
}
{
    funcName = RelObjectNameList()

    "(" [ [ LOOKAHEAD(2)(<K_DISTINCT> { retval.setDistinct(true); } | <K_ALL> { retval.setAllColumns(true); } | <K_UNIQUE> { retval.setUnique(true); }) ]
        ( LOOKAHEAD(4)
            "*" { expr1 = new AllColumns(); expressionList = new ExpressionList(expr1).withUsingBrackets(false); }
            |
            LOOKAHEAD(AllTableColumns()) expr1=AllTableColumns() { expressionList = new ExpressionList(expr1).withUsingBrackets(false); }
            |
            LOOKAHEAD(3, { getAsBoolean(Feature.allowComplexParsing) }) (expressionList=ComplexExpressionList() {expressionList.setUsingBrackets(false);} [ orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } ])
            |
            LOOKAHEAD(3) (expressionList=SimpleExpressionList(false) [ orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } ])
            |
            expr = SubSelect() { expr.setUseBrackets(false); expressionList = new ExpressionList(expr).withUsingBrackets(false); }

        )]
        [ <K_IGNORE> <K_NULLS> {retval.setIgnoreNulls(true); }]
        ")"

    [ "." (
            LOOKAHEAD(2) expr1=Function() { retval.setAttribute(expr1); }
            | tmp=RelObjectName() { retval.setAttributeName(tmp); }
          )
    ]

    [ LOOKAHEAD(2) keep = KeepExpression() ]

    {
        retval.setParameters(expressionList);
        retval.setName(funcName);
        retval.setKeep(keep);
        return retval;
    }
}

XMLSerializeExpr XMLSerializeExpr(): {
   XMLSerializeExpr result;
   Expression expression;
   List<OrderByElement> orderByElements = null;
   ColDataType dataType;
}
{
    <K_XMLSERIALIZE> 
        "(" <K_XMLAGG> 
                "(" <K_XMLTEXT> 
                        "(" expression=SimpleExpression() ")"
                [ orderByElements=OrderByElements() ]
        ")"
        <K_AS> dataType=ColDataType() ")"
    {
        result = new XMLSerializeExpr();
        result.setExpression(expression);
        result.setOrderByElements(orderByElements);
        result.setDataType(dataType);
        return result;
    }
}


MySQLGroupConcat MySQLGroupConcat():{
    MySQLGroupConcat retval = new MySQLGroupConcat();
    ExpressionList expressionList = null;
    List<OrderByElement> orderByList = null;
    Token t;
}
{
    <K_GROUP_CONCAT> "("
       [<K_DISTINCT>  { retval.setDistinct(true); } ]
       expressionList = SimpleExpressionList(true)
       [ orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } ]
       [ <K_SEPARATOR> t=<S_CHAR_LITERAL> { retval.setSeparator(t.image); } ]
    ")"
    {
        retval.setExpressionList(expressionList);
        return retval;
    }
}

ValueListExpression ValueListExpression():
{
    ValueListExpression retval = new ValueListExpression();
    ExpressionList expressionList = null;
}
{
    "(" expressionList = SimpleExpressionListAtLeastTwoItems() ")"
    {
        retval.setExpressionList(expressionList);
        return retval;
    }
}

TableFunction TableFunction():
{
    Alias alias = null;
    Function function;
    TableFunction functionItem;
}
{
    function=Function() {
      functionItem = new TableFunction().withFunction(function);
    }
             [LOOKAHEAD(2) alias=Alias() { functionItem.setAlias(alias); }]
    { return functionItem; }
}

SubSelect SubSelect() #SubSelect:
{
    SelectBody selectBody = null;
    SubSelect subSelect = new SubSelect();
    List<WithItem> with = null;
}
{
    [ with=WithList() { subSelect.setWithItemsList(with); } ]
    selectBody=SelectBody()
    {
        subSelect.setSelectBody(selectBody);
        linkAST(subSelect,jjtThis);
        return subSelect;
    }
}

List<Index.ColumnParams> ColumnNamesWithParamsList() : {
    List<Index.ColumnParams> colNames = new ArrayList<Index.ColumnParams>();
    String columnName;
    List<String> parameter = null;
}
{
     "("
    columnName=RelObjectName()

    { parameter = null; }
    [ parameter = CreateParameter() ]
    {
        colNames.add(new Index.ColumnParams(columnName,parameter));
    }

    (
        ","
        columnName=RelObjectName()

        { parameter = null; }
        [ parameter = CreateParameter() ]
        {
            colNames.add(new Index.ColumnParams(columnName,parameter));
        }
    )*

    ")"

    { return colNames; }
}

Index Index(): {
    List<String> name;
} 
{
    name= RelObjectNameList() { return new Index().withName(name).withType(""); }
}

CreateIndex CreateIndex():
{
    CreateIndex createIndex = new CreateIndex();
    Table table = null;
    List<Index.ColumnParams> colNames;
    //Token columnName;
    Token using;
    Index index = null;
    //String name = null;
    List<String> parameter = new ArrayList<String>();
    List<String> tailParameters = new ArrayList<String>();
    List<String> name;
}
{
    <K_CREATE>
    [ parameter=CreateParameter() ]

    <K_INDEX> index = Index() { index.setType(parameter.isEmpty()?null:parameter.get(0)); }

    <K_ON> table=Table()

    [ <K_USING> using=<S_IDENTIFIER> {index.setUsing(using.image);} ]

    colNames = ColumnNamesWithParamsList()

    /* [ tailParameter = CreateParameter() {} ] */

    ( parameter=CreateParameter() { tailParameters.addAll(parameter); } )*

    {
        index.setColumns(colNames);
        createIndex.setIndex(index);
        createIndex.setTable(table);
        createIndex.setTailParameters(tailParameters);
        return createIndex;
    }
}

ColumnDefinition ColumnDefinition(): {
    ColumnDefinition coldef;
    String columnName;
    ColDataType colDataType;
    List<String> columnSpecs = new ArrayList<String>();
    List<String> parameter;
} {
    columnName=RelObjectName()

    colDataType = ColDataType()

    ( LOOKAHEAD(2) parameter=CreateParameter() { columnSpecs.addAll(parameter); } )*

    {
        coldef = new ColumnDefinition();
        coldef.setColumnName(columnName);
        coldef.setColDataType(colDataType);
        if (columnSpecs.size() > 0)
            coldef.setColumnSpecs(columnSpecs);
        return coldef;
    }
}

CreateSchema CreateSchema():
{
    Token tk = null;
    CreateTable table = null;
    CreateView view = null;
    CreateSchema schema = new CreateSchema();
    //schema.setSchemaName(System.getProperty("user.name"));
    //schema.setAuthorization(System.getProperty("user.name"));
    List<String> schemaPath = null;
    List<Statement> statements = new ArrayList<Statement>();
}
{
    <K_CREATE> <K_SCHEMA>
    [ ( tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) { schema.setSchemaName(tk.image); } ]
    [ <K_AUTHORIZATION>
        (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) { schema.setAuthorization(tk.image); }
    ]

    [schemaPath=PathSpecification() { schema.setSchemaPath(schemaPath); }]

    (
        LOOKAHEAD(3)
        table = CreateTable()
        {
            table.getTable().setSchemaName(schema.getSchemaName());
            schema.addStatement(table);
        }
        | view = CreateView()
        {
            view.getView().setSchemaName(schema.getSchemaName());
            schema.addStatement(view);
        }

    )*
    {
        return schema;
    }
}

List<String> PathSpecification():
{
    Token tk;
    List<String> pathList = new ArrayList<String>();
}
{
    <K_PATH> (tk=<S_IDENTIFIER>|tk=<S_QUOTED_IDENTIFIER>) { pathList.add(tk.image); }
        ("," (tk=<S_IDENTIFIER>|tk=<S_QUOTED_IDENTIFIER>) { pathList.add(tk.image); })*
    {
        return pathList;
    }
}

CreateTable CreateTable():
{
    CreateTable createTable = new CreateTable();
    Table table = null;
    List<ColumnDefinition> columnDefinitions = new ArrayList<ColumnDefinition>();
    List<String> columnSpecs = null;
    List<String> tableOptions = new ArrayList<String>();
    List<String> createOptions = new ArrayList<String>();
    String columnName;
    Token tk = null;
    Token tk2 = null;
    Token tk3 = null;
    String sk3 = null;
    ColDataType colDataType = null;
    String stringList = null;
    ColumnDefinition coldef = null;
    List<Index> indexes = new ArrayList<Index>();
    List<Index.ColumnParams> colNames = null;
    List<String> colNames2 = null;
    Index index = null;
    ForeignKeyIndex fkIndex = null;
    List<String> parameter = new ArrayList<String>();
    List<String> idxSpec = new ArrayList<String>();
    Table fkTable = null;
    Select select = null;
    Table likeTable = null;
    CheckConstraint checkCs = null;
    ExcludeConstraint excludeC = null;
    RowMovement rowMovement = null;
    ReferentialAction.Action action = null;
    String tableColumn = null;
    List<String> columns = new ArrayList<String>();
}
{
    <K_CREATE>
    [ <K_OR> <K_REPLACE> { createTable.setOrReplace(true);} ]
    [ <K_UNLOGGED> { createTable.setUnlogged(true); } ]

    // table options, not required but 1 or none
    [ tk=<K_GLOBAL> { createOptions.add(tk.image);} ]
    /* [ [ (tk=<K_GLOBAL> | tk=<K_LOCAL>) {createOptions.add(tk.image);} ]
       ( tk=<K_TEMPORARY> | tk=<K_TEMP> ) {createOptions.add(tk.image);}] */

    (parameter = CreateParameter() { createOptions.addAll(parameter); })*

    <K_TABLE>
    [ LOOKAHEAD(2) <K_IF> <K_NOT> <K_EXISTS> { createTable.setIfNotExists(true); }]
    table=Table()
    [ LOOKAHEAD(2) ( 
        LOOKAHEAD(3) 
            ("(" tableColumn=RelObjectName() { columns.add(tableColumn); } ("," tableColumn=RelObjectName() { columns.add(tableColumn); } )* ")")
        |
            ("("
            coldef = ColumnDefinition()

            { columnDefinitions.add(coldef); }

            (
                ","

                (
                    LOOKAHEAD(3) (
                        tk=<K_INDEX>
                            sk3=RelObjectName()
                            /* colNames=ColumnsNamesList() */
                            colNames = ColumnNamesWithParamsList()
                            { idxSpec.clear(); }
                            ( parameter=CreateParameter() { idxSpec.addAll(parameter); } )*
                            {
                                index = new Index().withType(tk.image).withName(sk3).withColumns(colNames).withIndexSpec(new ArrayList<String>(idxSpec));
                                indexes.add(index);
                            }
                    )
                    |
                    LOOKAHEAD(3) (
                        {
                            index = new NamedConstraint();
                        }
                        [<K_CONSTRAINT> sk3=RelObjectName() {index.setName(sk3);} ]

                        (tk=<K_PRIMARY> tk2=<K_KEY> {index.setType(tk.image + " " + tk2.image);}
                         | tk=<K_UNIQUE> [ tk2=<K_KEY> ] {index.setType(tk.image + (tk2!=null?" " + tk2.image:""));}
                         )
                            /* colNames=ColumnsNamesList() */
                            colNames = ColumnNamesWithParamsList()
                            { idxSpec.clear(); }
                            ( parameter=CreateParameter() { idxSpec.addAll(parameter); } )*
                            {
                                index.withColumns(colNames).withIndexSpec(new ArrayList<String>(idxSpec));
                                indexes.add(index);
                            }
                            // reset Token to null forcefullly
                            {
                                 tk2=null;
                             }
                    )
                    |
                    LOOKAHEAD(3) ( {tk=null;}
                         [ tk=<K_UNIQUE> ] [ tk3=<K_FULLTEXT> ] tk2=<K_KEY>
                            sk3=RelObjectName()
                            /* colNames=ColumnsNamesList() */
                            colNames = ColumnNamesWithParamsList()
                            { idxSpec.clear(); }
                            ( parameter=CreateParameter() { idxSpec.addAll(parameter); } )*
                            {
                                index = new Index()
                                .withType((tk!=null?tk.image + " ":"") + (tk3!=null?tk3.image + " ":"") + tk2.image)
                                .withName(sk3)
                                .withColumns(colNames)
                                .withIndexSpec(new ArrayList<String>(idxSpec));
                                indexes.add(index);
                            }
                    )
                    |
                    LOOKAHEAD(3)(
                        {
                            fkIndex = new ForeignKeyIndex();
                        }
                        [<K_CONSTRAINT> sk3=RelObjectName() {fkIndex.setName(sk3);} ]
                        tk=<K_FOREIGN> tk2=<K_KEY>
                            /* colNames=ColumnsNamesList() */
                            colNames = ColumnNamesWithParamsList()
                            {
                                fkIndex.withType(tk.image + " " + tk2.image).withColumns(colNames);
                            }
                            <K_REFERENCES> fkTable=Table() colNames2=ColumnsNamesList()
                            {
                                fkIndex.setTable(fkTable);
                                fkIndex.setReferencedColumnNames(colNames2);
                                indexes.add(fkIndex);
                            }
                    [LOOKAHEAD(2) (<K_ON> (tk=<K_DELETE> | tk=<K_UPDATE>) action = Action()
                                      { fkIndex.setReferentialAction(ReferentialAction.Type.valueOf(tk.image), action); }
                                      )]
                    [LOOKAHEAD(2) (<K_ON> (tk=<K_DELETE> | tk=<K_UPDATE>) action = Action()
                                      { fkIndex.setReferentialAction(ReferentialAction.Type.valueOf(tk.image), action); }
                                      )]
                    )
                    |
                     LOOKAHEAD(3)(
                        [<K_CONSTRAINT>  sk3 = RelObjectName()]
                        {Expression exp = null;}
                        <K_CHECK>  ("(" exp = Expression() ")")* {
                           checkCs = new CheckConstraint().withName(sk3).withExpression(exp);
                           indexes.add(checkCs);
                           }
                    )
                    |
                        LOOKAHEAD(2) tk=<K_EXCLUDE> {excludeC = new ExcludeConstraint(); Expression exp = null;}
                        (tk2=<K_WHERE>
                            ("(" exp = Expression() ")")* {excludeC.setExpression(exp);})
                        {
                            indexes.add(excludeC);
                        }
                    |
                    (

                        coldef = ColumnDefinition()

                        /*
                        columnName=RelObjectName()

                        colDataType = ColDataType()
                        {
                            columnSpecs = new ArrayList<String>();
                        }

                        (     parameter=CreateParameter() { columnSpecs.addAll(parameter); }     )*

                        {
                            coldef = new ColumnDefinition();
                            coldef.setColumnName(columnName);
                            coldef.setColDataType(colDataType);
                            if (columnSpecs.size() > 0)
                                coldef.setColumnSpecs(columnSpecs);
                            columnDefinitions.add(coldef);
                        } */
                        { columnDefinitions.add(coldef); }
                    )
                )
            )*

            ")"
            )
          )
    ]
    ( LOOKAHEAD(2, { getToken(1).kind != K_AS }) parameter=CreateParameter() { tableOptions.addAll(parameter); } )*

    // see https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_7002.htm#i2126725
    // table properties , all these are optional
    [ rowMovement = RowMovement() { createTable.setRowMovement(rowMovement); }]
    [ <K_AS> select = SelectWithWithItems( ) { createTable.setSelect(select, false); }]
    [
    <K_LIKE> ( LOOKAHEAD("(" Table() ")") "(" likeTable=Table() { createTable.setLikeTable(likeTable, true); } ")"
                 | likeTable=Table() { createTable.setLikeTable(likeTable, false); } )
    ]
    {
        createTable.setTable(table);
        if (indexes.size() > 0)
            createTable.setIndexes(indexes);
        if (createOptions.size() > 0)
            createTable.setCreateOptionsStrings(createOptions);
        if (tableOptions.size() > 0)
            createTable.setTableOptionsStrings(tableOptions);
        if (columnDefinitions.size() > 0)
            createTable.setColumnDefinitions(columnDefinitions);
        if (columns.size() > 0)
            createTable.setColumns(columns);
        return createTable;
    }
}

ColDataType ColDataType():
{
    ColDataType colDataType = new ColDataType();
    Token tk = null;
    Token tk2 = null;
    List<String> argumentsStringList = new ArrayList<String>();
    List<Integer> array = new ArrayList<Integer>();
    List<String> name;
}
{
    (
		(tk=<K_CHARACTER> | tk=<K_BIT>) [tk2=<K_VARYING>] { colDataType.setDataType(tk.image + (tk2!=null?" " + tk2.image:"")); }
		| tk=<K_DOUBLE> [LOOKAHEAD(2) tk2=<K_PRECISION>] { colDataType.setDataType(tk.image + (tk2!=null?" " + tk2.image:"")); }
		| ( tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER> | tk=<K_DATETIMELITERAL> | tk=<K_DATE_LITERAL> | tk=<K_XML> | tk=<K_INTERVAL>
			| tk=<DT_ZONE> | tk=<K_CHAR> | tk=<K_SET> | tk=<K_BINARY> | tk=<K_JSON> )
                        [ "." (tk2=<S_IDENTIFIER> | tk2=<S_QUOTED_IDENTIFIER>) ]
		    { if (tk2!=null) colDataType.setDataType(tk.image + "." + tk2.image); else colDataType.setDataType(tk.image); }
		| tk=<K_UNSIGNED>  [LOOKAHEAD(2) tk2=<S_IDENTIFIER>] 
                    { if (tk2!=null) colDataType.setDataType(tk.image + " " + tk2.image); else colDataType.setDataType(tk.image); } 
		| LOOKAHEAD(2) tk=<K_SIGNED> tk2=<S_IDENTIFIER> {colDataType.setDataType(tk.image + " " + tk2.image);}
		| tk=<K_SIGNED> { colDataType.setDataType(tk.image);}
    )

    [LOOKAHEAD(2) "(" {tk2 =null;} ( ( ( tk=<S_LONG> [ LOOKAHEAD(2) (tk2=<K_BYTE> | tk2=<K_CHAR>) ] ) | tk=<S_CHAR_LITERAL> | tk=<S_IDENTIFIER> | tk=<K_CHAR> )
		{ argumentsStringList.add(tk.image + (tk2!=null?" " + tk2.image:"")); } ["," {/*argumentsStringList.add(",");*/}] )*    ")"]
    [( "[" {tk=null;} [ tk=<S_LONG> ] { array.add(tk!=null?Integer.valueOf(tk.image):null); } "]" )+ { colDataType.setArrayData(array); } ]
    [LOOKAHEAD(2) <K_CHARACTER> <K_SET> (tk=<S_IDENTIFIER> | tk=<K_BINARY>) { colDataType.setCharacterSet(tk.image); } ]

    {
        if (argumentsStringList.size() > 0)
            colDataType.setArgumentsStringList(argumentsStringList);
        return colDataType;
    }
}

Analyze Analyze():
{
    Analyze analyze = new Analyze();
    Table table = null;
}
{
    <K_ANALYZE>
    table=Table()

    {
    	analyze.setTable(table);
    	return analyze;
    }
}

CreateView CreateView():
{
    CreateView createView = new CreateView();
    Table view = null;
    Select select = null;
    List<String> columnNames = null;
}
{
    <K_CREATE>
    [ <K_OR> <K_REPLACE> { createView.setOrReplace(true);} ]
    [
        <K_NO> <K_FORCE> { createView.setForce(ForceOption.NO_FORCE); }
        | <K_FORCE> { createView.setForce(ForceOption.FORCE); }
    ]
    [
        <K_TEMP> { createView.setTemporary(TemporaryOption.TEMP); }
        | <K_TEMPORARY> { createView.setTemporary(TemporaryOption.TEMPORARY); }
    ]
    [ <K_MATERIALIZED> { createView.setMaterialized(true);} ]
    <K_VIEW> view=Table() { createView.setView(view); }
    [ columnNames = ColumnsNamesList() { createView.setColumnNames(columnNames); } ]
    <K_AS>
    select=SelectWithWithItems( ) { createView.setSelect(select); }
    [ <K_WITH> <K_READ> <K_ONLY> { createView.setWithReadOnly(true); } ]
    { return createView; }
}

ReferentialAction.Action Action():
{
    ReferentialAction.Action action = null;
}
{
    (<K_CASCADE> { action=ReferentialAction.Action.CASCADE;}
     |
     <K_RESTRICT> {action=ReferentialAction.Action.RESTRICT;}
     |
     <K_NO> <K_ACTION> {action=ReferentialAction.Action.NO_ACTION;}
     |
     <K_SET> (
	          <K_NULL> {action=ReferentialAction.Action.SET_NULL;}
              |
              <K_DEFAULT> {action=ReferentialAction.Action.SET_DEFAULT;}
             )
     )
    { return action; }
}

AlterView AlterView():
{
    AlterView alterView = new AlterView();
    Table view = null;
    SelectBody select = null;
    List<String> columnNames = null;
}
{
    ( (<K_ALTER> ) | (<K_REPLACE> {alterView.setUseReplace(true);}) )
    <K_VIEW> view=Table() { alterView.setView(view); }
    [ columnNames = ColumnsNamesList() { alterView.setColumnNames(columnNames); } ]
    <K_AS>
    select=SelectBody() { alterView.setSelectBody(select); }
    { return alterView; }
}

List<String> CreateParameter():
{
    String retval = "";
    Token tk = null;
    Token tk2 = null;
    StringBuilder identifier = new StringBuilder("");
    Expression exp = null;
    List<String> param = new ArrayList<String>();
    ColDataType colDataType;
}
{
        (
            (((tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) { identifier.append(tk.image); }
                ["." (tk2=<S_IDENTIFIER> | tk2=<S_QUOTED_IDENTIFIER>) { identifier.append("."); identifier.append(tk2.image); }])
                { param.add(identifier.toString()); })
            |
            tk=<K_NULL> { param.add(tk.image); }
            |
            tk=<K_NOT> { param.add(tk.image); }
            |
            tk=<K_PRIMARY> { param.add(tk.image); }
            |
            tk=<K_DEFAULT> { param.add(tk.image); }
            |
            tk=<K_FOREIGN> { param.add(tk.image); }
            |
            tk=<K_REFERENCES> { param.add(tk.image); }
            |
            tk=<K_KEY> { param.add(tk.image); }
            |
            tk=<S_CHAR_LITERAL> { param.add(tk.image); }
            |
              ("+" {retval = "+";} | "-" {retval = "-";})?
              (
               tk=<S_LONG> { retval += tk.image; }
               |
               tk=<S_DOUBLE> { retval += tk.image; }
              )
              { param.add(retval); }
            |
            tk=<K_AS> { param.add(tk.image); }
            |
            tk=<K_ON> { param.add(tk.image); }
            |
            tk=<K_COMMIT> { param.add(tk.image); }
            |
            tk=<K_DROP> { param.add(tk.image); }
            |
            tk=<K_ROWS> { param.add(tk.image); }
            |
            tk=<K_UNIQUE> { param.add(tk.image); }
            |
            tk=<K_CASCADE> { param.add(tk.image); }
            |
            tk=<K_DELETE> { param.add(tk.image); }
            |
            tk=<K_UPDATE> { param.add(tk.image); }
            |
            tk=<K_TIME_KEY_EXPR> { param.add(new TimeKeyExpression(tk.image).toString()); }
            |
            "=" { param.add("="); }
            |
            LOOKAHEAD(3) <K_USING> <K_INDEX> <K_TABLESPACE> retval=RelObjectName() { param.add("USING"); param.add("INDEX"); param.add("TABLESPACE"); param.add(retval); }
            |
            <K_TABLESPACE> retval=RelObjectName() { param.add("TABLESPACE"); param.add(retval); }
            |
            retval=AList() { param.add(retval); }
            |
            <K_CHECK>  ("(" exp = Expression() ")") { param.add("CHECK"); param.add("(" + exp.toString() + ")");}
            |
            tk=<K_CONSTRAINT> { param.add(tk.image); }
            |
            tk=<K_WITH> { param.add(tk.image); }
            |
            tk=<K_EXCLUDE> { param.add(tk.image); }
            |
            tk=<K_WHERE> { param.add(tk.image); }
            |
            tk=<K_UNSIGNED> { param.add(tk.image); }
            |
            tk=<K_TEMP> { param.add(tk.image); }
            |
            tk=<K_TEMPORARY> { param.add(tk.image); }
            |
            tk=<K_PARTITION> { param.add(tk.image); }
            |
            tk=<K_BY> { param.add(tk.image); }
            |
            tk=<K_IN> { param.add(tk.image); }
            |
            tk=<K_TYPE> { param.add(tk.image); }
            |
            tk=<K_COMMENT> { param.add(tk.image); }
            |
            tk=<K_USING> { param.add(tk.image); }
            |
            tk=<K_COLLATE> { param.add(tk.image); }
            |
            tk=<K_ASC> { param.add(tk.image); }
            |
            tk=<K_DESC> { param.add(tk.image); }
            |
            tk=<K_TRUE> { param.add(tk.image); }
            |
            tk=<K_FALSE> { param.add(tk.image); }
            |
            tk=<K_PARALLEL> { param.add(tk.image); }
            |
            tk=<K_BINARY> { param.add(tk.image); }
            |
            (tk=<K_CHARACTER> tk2=<K_SET>) { param.add(tk.image); param.add(tk2.image);}
            |
            (<K_ARRAY_LITERAL> exp=ArrayConstructor(true)) { param.add(exp.toString()); }
            |
	    tk="::" colDataType = ColDataType() { param.add(tk.image); param.add(colDataType.toString()); }
        )
    {return param;}
}

// row_movement_clause https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_7002.htm#i2204697
RowMovement RowMovement():
{
  RowMovement rowMovement = new RowMovement();
}
{
  (
    (<K_ENABLE> <K_ROW> <K_MOVEMENT>) { rowMovement.setMode(RowMovementMode.ENABLE); }
    |
    (<K_DISABLE> <K_ROW> <K_MOVEMENT>) { rowMovement.setMode(RowMovementMode.DISABLE); }
  )
  { return rowMovement;}
}

String AList():
{
    StringBuilder retval = new StringBuilder("(");
    Token tk = null;
    String name = null;
}
{
     "("

     (
       ( (tk=<S_LONG> | tk=<S_DOUBLE> | tk=<S_CHAR_LITERAL>) { retval.append(tk.image); }
         | (name=RelObjectNameWithoutValue()) { retval.append(name); })
       [("," {retval.append(",");} | "=" {retval.append("=");})] )*

    ")"
    {
        retval.append(")");
        return retval.toString();
    }
}

String ColumnsNamesListItem():
{
	Token tk = null;
    String item = null;
}
{
	( item = RelObjectName() )
	[ "(" tk = <S_LONG>  ")" { item = item + "(" + tk.image + ")"; } ]
	{
		return item;
	}
}

List<String> ColumnsNamesList():
{
    List<String> retval = new ArrayList<String>();
    String img = null;
}
{
    "("
         img=ColumnsNamesListItem() { retval.add(img); }
         ( "," img=ColumnsNamesListItem() { retval.add(img); } )*

    ")"
    {
        return retval;
    }
}

String FuncArgsListItem():
{
	Token tk = null;
    String argName = null;
    String argType = null;
}
{
    (
        LOOKAHEAD(2) (
            argName = RelObjectName()
            argType = RelObjectName()
            [ "(" tk = <S_LONG>  ")" { argType = argType + "(" + tk.image + ")"; } ]
        )
        |
        (
            argType = RelObjectName()
            [ "(" tk = <S_LONG>  ")" { argType = argType + "(" + tk.image + ")"; } ]
        )
    )
	{
	    return argName != null ? String.format("%s %s", argName, argType) : argType;
	}
}

List<String> FuncArgsList():
{
    List<String> retval = null;
    String img = null;
}
{
    "("
         { retval = new ArrayList<String>(); }
         [
            img=FuncArgsListItem() { retval.add(img); }
            ( "," img=FuncArgsListItem() { retval.add(img); } )*
         ]
    ")"
    {
        return retval;
    }
}

Drop Drop():
{
    Drop drop = new Drop();
    Token tk = null;
    Table name;
    List<String> dropArgs = new ArrayList<String>();
    List<String> funcArgs = null;
}
{
    <K_DROP>
    (
        tk=<S_IDENTIFIER>
        |
        tk=<K_TABLE>
        |
        tk=<K_INDEX>
        |
        tk=<K_VIEW>
        |
        tk=<K_SCHEMA>
        |
        tk=<K_SEQUENCE>
        |
        tk=<K_FUNCTION>
    )
    { drop.setType(tk.image); }

    [ LOOKAHEAD(2) <K_IF> <K_EXISTS> {drop.setIfExists(true);} ]

    name = Table() { drop.setName(name); }
    [ funcArgs = FuncArgsList() ]
    ((tk=<S_IDENTIFIER> | tk=<K_CASCADE> | tk=<K_RESTRICT> ) { dropArgs.add(tk.image); })*

    {
        if (dropArgs.size() > 0) {
            drop.setParameters(dropArgs);
        }
        if (drop.getType().equals("FUNCTION")) {
            drop.getTypeToParameters().put("FUNCTION", funcArgs);
        }

        return drop;
    }
}

Truncate Truncate():
{
    Truncate truncate = new Truncate();
    Table table;
}
{
/**
* TRUNCATE can be followed directly by the table name in Postgresql
* See: https://www.postgresql.org/docs/current/sql-truncate.html
*
* TRUNCATE [ TABLE ] [ ONLY ] name [ * ] [, ... ]
*      [ RESTART IDENTITY | CONTINUE IDENTITY ] [ CASCADE | RESTRICT ]
*
*/
    <K_TRUNCATE> [LOOKAHEAD(2) <K_TABLE>  {truncate.setTableToken(true);}] [<K_ONLY>  {truncate.setOnly(true);}]
	table=Table() { truncate.setTable(table); truncate.setCascade(false); } [ <K_CASCADE> {truncate.setCascade(true);} ]
    {
        return truncate;
    }
}


AlterExpression.ColumnDataType AlterExpressionColumnDataType():
{
    String columnName = null;
    boolean withType = false;
    ColDataType dataType = null;
    List<String> columnSpecs = null;
    List<String> parameter = null;
}
{
    columnName = RelObjectName()
    (<K_TYPE> { withType = true; } )?
    dataType = ColDataType() { columnSpecs = new ArrayList<String>(); }
    ( parameter = CreateParameter() { columnSpecs.addAll(parameter); } )*
    {
        return new AlterExpression.ColumnDataType(columnName, withType, dataType, columnSpecs);
    }
}

AlterExpression.ColumnDropNotNull AlterExpressionColumnDropNotNull():
{
    String columnName = null;
    boolean withNot = false;
    ColDataType dataType = null;
    List<String> columnSpecs = null;
    List<String> parameter = null;
}
{
    columnName = RelObjectName()
    <K_DROP>
    (<K_NOT> { withNot = true; } )?
    <K_NULL>
    {
        return new AlterExpression.ColumnDropNotNull(columnName, withNot);
    }
}

AlterExpression.ColumnDropDefault AlterExpressionColumnDropDefault():
{
    String columnName = null;
    boolean withNot = false;
    ColDataType dataType = null;
    List<String> columnSpecs = null;
    List<String> parameter = null;
}
{
    columnName = RelObjectName() <K_DROP> <K_DEFAULT>
    {
        return new AlterExpression.ColumnDropDefault(columnName);
    }
}

List<ConstraintState> AlterExpressionConstraintState():
{
    List<ConstraintState> retval = new ArrayList<ConstraintState>();
}
{
    (
        (
          <K_DEFERRABLE> {retval.add(new DeferrableConstraint(false));}
        )
        |
        (
          <K_NOT> <K_DEFERRABLE> {retval.add(new DeferrableConstraint(true));}
        )
        |
        (
          <K_VALIDATE> {retval.add(new ValidateConstraint(false));}
        )
        |
        (
          <K_NOVALIDATE> {retval.add(new ValidateConstraint(true));}
        )
        |
        (
          <K_ENABLE> {retval.add(new EnableConstraint(false));}
        )
        |
        (
          <K_DISABLE> {retval.add(new EnableConstraint(true));}
        )
    )*
    {
        return retval;
    }
}


/**
* This production needs refactoring to multiple smaller productions. The target class should
* be splitted as well.
*/
AlterExpression AlterExpression():
{
    AlterExpression alterExp = new AlterExpression();
    Token tk;
    Token tk2 = null;
    String sk3 = null;
    String sk4 = null;
    ColDataType dataType;
    List<String> columnNames = null;
    List<ConstraintState> constraints = null;
    ForeignKeyIndex fkIndex = null;
    Index index = null;
    Table fkTable = null;
    AlterExpression.ColumnDataType alterExpressionColumnDataType = null;
    AlterExpression.ColumnDropNotNull alterExpressionColumnDropNotNull = null;
    AlterExpression.ColumnDropDefault alterExpressionColumnDropDefault = null;
    ReferentialAction.Action action = null;

    // for captureRest()
    List<String> tokens = new LinkedList<String>();
}
{

    (
        ((<K_ADD>    { alterExp.setOperation(AlterOperation.ADD); } | <K_ALTER>    { alterExp.setOperation(AlterOperation.ALTER); } | <K_MODIFY> { alterExp.setOperation(AlterOperation.MODIFY); })
        (
                  LOOKAHEAD(2) (
                      <K_PRIMARY> <K_KEY> columnNames=ColumnsNamesList() { alterExp.setPkColumns(columnNames); }
                  ) constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
                  [<K_USING> sk4=RelObjectName() { alterExp.addParameters("USING", sk4); }]
                  |
            LOOKAHEAD(2) (
              (tk=<K_KEY> { alterExp.setUk(true); } | tk=<K_INDEX>)
              sk3 = RelObjectName()
              columnNames = ColumnsNamesList()
              {
                index = new Index().withType(tk.image).withName(sk3).withColumnsNames(columnNames);
                alterExp.setIndex(index);
              }
              constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
              [<K_USING> sk4=RelObjectName() { alterExp.addParameters("USING", sk4); }]
            )
                    |
            LOOKAHEAD(3) (
                ( LOOKAHEAD(2) <K_COLUMN> { alterExp.hasColumn(true); } )?

                (
                    LOOKAHEAD(2) alterExpressionColumnDataType = AlterExpressionColumnDataType() {
                            alterExp.addColDataType(alterExpressionColumnDataType);
                         }
                    |
                    LOOKAHEAD(3) alterExpressionColumnDropNotNull = AlterExpressionColumnDropNotNull() {
                            alterExp.addColDropNotNull( alterExpressionColumnDropNotNull);
                         }
                    |
                    LOOKAHEAD(4) "("
                                   (  alterExpressionColumnDataType = AlterExpressionColumnDataType() {
                                        if (alterExp.getOperation()== AlterOperation.ADD ){
                                           alterExp.addColDataType(alterExpressionColumnDataType);
                                       } else if(alterExp.getOperation()== AlterOperation.ALTER){
                                            error_skipto(K_ALTER);
                                       }else if(alterExp.getOperation()== AlterOperation.MODIFY){
                                            error_skipto(K_MODIFY);
                                       }
                                    }
                                      (LOOKAHEAD(2) "," alterExpressionColumnDataType = AlterExpressionColumnDataType() { alterExp.addColDataType(alterExpressionColumnDataType); }) *
                                    )
                              ")" {alterExp.useBrackets(true);}
                    |
                    alterExpressionColumnDropDefault = AlterExpressionColumnDropDefault() {
                            alterExp.addColDropDefault( alterExpressionColumnDropDefault);
                         }
                )
            )
            |
            (
                "(" alterExpressionColumnDataType = AlterExpressionColumnDataType() { alterExp.addColDataType(alterExpressionColumnDataType); }
                    ("," alterExpressionColumnDataType = AlterExpressionColumnDataType() { alterExp.addColDataType(alterExpressionColumnDataType); } )* ")"
            )
            |
            ( <K_UNIQUE> ((<K_KEY> { alterExp.setUk(true); } | <K_INDEX>) (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) { alterExp.setUkName(tk.image); } )?
                columnNames=ColumnsNamesList() { alterExp.setUkColumns(columnNames); }
                [<K_USING> sk4=RelObjectName() { alterExp.addParameters("USING", sk4); }])
            |
    //following two choices regarding foreign keys should be merged
            ( <K_FOREIGN> <K_KEY> columnNames=ColumnsNamesList() { alterExp.setFkColumns(columnNames); columnNames = null; }
                 /*
                    <K_REFERENCES> tk=<S_IDENTIFIER> [ columnNames=ColumnsNamesList() ]
                        { alterExp.setFkSourceTable(tk.image); alterExp.setFkSourceColumns(columnNames); }
                 */
                 <K_REFERENCES> fkTable=Table() [ columnNames=ColumnsNamesList() ]
                    {
                        alterExp.setFkSourceSchema(fkTable.getSchemaName());
                        alterExp.setFkSourceTable(fkTable.getName());
                        alterExp.setFkSourceColumns(columnNames); 
                    }
                                
                [LOOKAHEAD(2) (<K_ON> (tk=<K_DELETE> | tk=<K_UPDATE>) action = Action()
                        		  { alterExp.setReferentialAction(ReferentialAction.Type.valueOf(tk.image), action); }
                                  )]
                [LOOKAHEAD(2) (<K_ON> (tk=<K_DELETE> | tk=<K_UPDATE>) action = Action()
                        		  { alterExp.setReferentialAction(ReferentialAction.Type.valueOf(tk.image), action); }
                           		  )]
            )
            |
            (
                <K_CONSTRAINT> sk3=RelObjectName()

                ( ( tk=<K_FOREIGN> tk2=<K_KEY>
                    columnNames=ColumnsNamesList()
                    {
                        fkIndex = new ForeignKeyIndex()
                        .withName(sk3)
                        .withType(tk.image + " " + tk2.image)
                        .withColumnsNames(columnNames);
                                            columnNames = null;
                    }
                    <K_REFERENCES> fkTable=Table() [ columnNames=ColumnsNamesList() ]
                    {
                        fkIndex.withTable(fkTable).withReferencedColumnNames(columnNames);
                        alterExp.setIndex(fkIndex);
                    }
                                
                [LOOKAHEAD(2) (<K_ON> (tk=<K_DELETE> | tk=<K_UPDATE>) action = Action()
                        		  { fkIndex.setReferentialAction(ReferentialAction.Type.valueOf(tk.image), action); }
                                  )]
                [LOOKAHEAD(2) (<K_ON> (tk=<K_DELETE> | tk=<K_UPDATE>) action = Action()
                        		  { fkIndex.setReferentialAction(ReferentialAction.Type.valueOf(tk.image), action); }
                           		  )]
                    constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
                )
                |
                ( tk=<K_PRIMARY> tk2=<K_KEY>
                    columnNames=ColumnsNamesList()
                    {
                        index = new NamedConstraint()
                        .withName(sk3)
                        .withType(tk.image + " " + tk2.image)
                        .withColumnsNames(columnNames);
                        alterExp.setIndex(index);
                    }
                    constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
                    [<K_USING> sk4=RelObjectName() { alterExp.addParameters("USING", sk4); }]
                )
                |
                (
                    <K_CHECK>  {Expression exp = null;} ("(" exp = Expression() ")")* {
                    CheckConstraint checkCs = new CheckConstraint().withName(sk3).withExpression(exp);
                    alterExp.setIndex(checkCs);
                }
                )
                |
                (
                    tk=<K_UNIQUE> (tk2=<K_KEY> { alterExp.setUk(true); } | tk2=<K_INDEX>)?
                      columnNames=ColumnsNamesList()
                      {
                          index = new NamedConstraint()
                            .withName(sk3)
                          	.withType(tk.image + (tk2!=null?" " + tk2.image:""))
                          	.withColumnsNames(columnNames);
                          alterExp.setIndex(index);
                      }
                      constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
                      [<K_USING> sk4=RelObjectName() { alterExp.addParameters("USING", sk4); }]
                )
                |
                (
                    tk=<K_KEY>
                      columnNames=ColumnsNamesList()
                      {
                          index = new NamedConstraint()
                          	.withName(sk3)
                          	.withType(tk.image)
							.withColumnsNames(columnNames);
                          alterExp.setIndex(index);
                      }
                      constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
                )
                             )
            )
            |
            ( sk3=RelObjectName() <K_COMMENT> 
                tk=<S_CHAR_LITERAL> { 
                    alterExp.withColumnName(sk3).withCommentText(tk.image); 
                }
            )
          )
      )
      |
      (
        <K_CHANGE> { alterExp.setOperation(AlterOperation.CHANGE); }
        [ <K_COLUMN> { alterExp.hasColumn(true); alterExp.setOptionalSpecifier("COLUMN"); } ]
        (
          (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>)
          alterExpressionColumnDataType = AlterExpressionColumnDataType() {  alterExp.withColumnOldName(tk.image).addColDataType(alterExpressionColumnDataType); }
        )
      )
      |
        <K_DROP> { alterExp.setOperation(AlterOperation.DROP);          }
        (
            (
                (
                    // we use the PK Columns Field instead of the Column Field
                    // for holding multiple DROP Columns
                    columnNames=ColumnsNamesList() { alterExp.setPkColumns(columnNames); columnNames = null; }

                    [ "INVALIDATE" { alterExp.addParameters("INVALIDATE"); } ]

                    [
                        "CASCADE" { alterExp.addParameters("CASCADE"); }
                        [ "CONSTRAINTS" { alterExp.addParameters("CONSTRAINTS"); } ]
                    ]
                )
                |
                (
                    ( LOOKAHEAD(2) <K_COLUMN> { alterExp.hasColumn(true); } )?
                    [<K_IF> <K_EXISTS> { alterExp.setUsingIfExists(true); } ]
                    (tk=<S_IDENTIFIER>    | tk=<S_QUOTED_IDENTIFIER>) { alterExp.setColumnName(tk.image); }

                    [ "INVALIDATE" { alterExp.addParameters("INVALIDATE"); } ]

                    [
                        "CASCADE" { alterExp.addParameters("CASCADE"); }
                        [ "CONSTRAINTS" { alterExp.addParameters("CONSTRAINTS"); } ]
                    ]
                )
            )
            |
            (
               tk=<K_INDEX>
               ( tk2=<S_IDENTIFIER> | tk2=<S_QUOTED_IDENTIFIER> ) {
                       index = new Index().withType(tk.image).withName(tk2.image);
                       alterExp.setIndex(index);
                   }
            )
            |
            (
               tk=<K_UNIQUE>  { alterExp.setOperation(AlterOperation.DROP_UNIQUE); }
               columnNames=ColumnsNamesList() { alterExp.setPkColumns(columnNames); columnNames = null; }
               [ ( tk=<K_CASCADE> | tk=<K_RESTRICT> ) { alterExp.addParameters(tk.image); } ]
            )
            |
            (
               tk=<K_PRIMARY> tk2=<K_KEY> { alterExp.setOperation(AlterOperation.DROP_PRIMARY_KEY); }
               [ ( tk=<K_CASCADE> | tk=<K_RESTRICT> ) { alterExp.addParameters(tk.image); } ]
            )
            |
            (
               tk=<K_FOREIGN> tk2=<K_KEY> { alterExp.setOperation(AlterOperation.DROP_FOREIGN_KEY); }
               columnNames=ColumnsNamesList() { alterExp.setPkColumns(columnNames); columnNames = null; }
               [ ( tk=<K_CASCADE> | tk=<K_RESTRICT> ) { alterExp.addParameters(tk.image); } ]
            )
            |
            (
                <K_CONSTRAINT> [<K_IF> <K_EXISTS> { alterExp.setUsingIfExists(true); } ]
                ( tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) { alterExp.setConstraintName(tk.image); }
                [ ( tk=<K_CASCADE> | tk=<K_RESTRICT> ) { alterExp.addParameters(tk.image); } ]
            )
        )
        |
      (<K_ALGORITHM>
         {
            alterExp.setOperation(AlterOperation.ALGORITHM);
         }
         ["=" { alterExp.setUseEqual(true);} ]
         sk3 = RelObjectName() {alterExp.addParameters(sk3); }
      )
      |
      LOOKAHEAD(2)   <K_RENAME> { alterExp.setOperation(AlterOperation.RENAME); } [ <K_COLUMN> {  alterExp.hasColumn(true);} ]
                    ( tk=<S_IDENTIFIER>    | tk=<S_QUOTED_IDENTIFIER> ) { alterExp.setColOldName(tk.image); }
                    <K_TO>
                    (tk2=<S_IDENTIFIER>    | tk2=<S_QUOTED_IDENTIFIER>) { alterExp.setColumnName(tk2.image); }
      |
      (
        <K_RENAME> <K_TO> {alterExp.setOperation(AlterOperation.RENAME_TABLE);}
        (tk2=<S_IDENTIFIER>    | tk2=<S_QUOTED_IDENTIFIER>) { alterExp.setNewTableName(tk2.image);}
      )
      |
      (<K_COMMENT> {alterExp.setOperation(AlterOperation.COMMENT);}
          tk=<S_CHAR_LITERAL> { alterExp.setCommentText(tk.image); }
      )
      |
      tokens = captureRest() { 
                    alterExp.setOperation(AlterOperation.UNSPECIFIC);
                    StringBuilder optionalSpecifier = new StringBuilder();
                    int i=0;

                    for (String s: tokens) 
                        if (!s.equals(";")) {
                            if (i>0)
                                optionalSpecifier.append( " " );
                            optionalSpecifier.append( s );
                            i++;
                        }

                    alterExp.setOptionalSpecifier( optionalSpecifier.toString() );
                }
    )

    {
        return alterExp;
    }
}


Alter AlterTable():
{
    Alter alter = new Alter();
    Table table;
    AlterExpression alterExp;
    boolean usingIfExists = false;
}
{
    <K_ALTER> <K_TABLE>
    [ <K_ONLY> { alter.setUseOnly(true); } ]
    [ LOOKAHEAD(2) <K_IF> <K_EXISTS> { usingIfExists = true; } ]

    table=Table() { alter.setTable(table); }

    alterExp=AlterExpression() { if (usingIfExists)
                                    alter.addAlterExpression( alterExp.withUsingIfExists(true) );
                                  else
                                    alter.addAlterExpression(alterExp); }

    ("," alterExp=AlterExpression() { alter.addAlterExpression(alterExp); } )*

    {
        return alter;
    }
}

AlterSession AlterSession():
{
    AlterSessionOperation operation = null;
    List<String> parameters = new ArrayList<String>();
    Token token;
}
{
    <K_ALTER> <K_SESSION> (
        ( 
           <K_ADVISE>   ( <K_COMMIT> { operation = AlterSessionOperation.ADVISE_COMMIT; }
                        | <K_ROLLBACK> { operation = AlterSessionOperation.ADVISE_ROLLBACK; }
                        | <K_NOTHING> { operation = AlterSessionOperation.ADVISE_NOTHING; }
                        )
        )
        |
        ( 
            <K_CLOSE> <K_DATABASE> <K_LINK> { operation = AlterSessionOperation.CLOSE_DATABASE_LINK; }
        )
        |   
        (   
            <K_ENABLE>  ( <K_COMMIT> <K_IN> <K_PROCEDURE> { operation = AlterSessionOperation.ENABLE_COMMIT_IN_PROCEDURE; }
                        | <K_GUARD> { operation = AlterSessionOperation.ENABLE_GUARD; }
                        | <K_PARALLEL> ( <K_DML> { operation = AlterSessionOperation.ENABLE_PARALLEL_DML; }
                                       | <K_DDL> { operation = AlterSessionOperation.ENABLE_PARALLEL_DDL; }
                                       | <K_QUERY> { operation = AlterSessionOperation.ENABLE_PARALLEL_QUERY; }
                                       )
                        | <K_RESUMABLE> { operation = AlterSessionOperation.ENABLE_RESUMABLE; }
                        )
        )
        |
        (   
            <K_DISABLE> ( <K_COMMIT> <K_IN> <K_PROCEDURE> { operation = AlterSessionOperation.DISABLE_COMMIT_IN_PROCEDURE; }
                        | <K_GUARD> { operation = AlterSessionOperation.DISABLE_GUARD; }
                        | <K_PARALLEL> ( <K_DML> { operation = AlterSessionOperation.DISABLE_PARALLEL_DML; }
                                        | <K_DDL> { operation = AlterSessionOperation.DISABLE_PARALLEL_DDL; }
                                        | <K_QUERY> { operation = AlterSessionOperation.DISABLE_PARALLEL_QUERY; }
                                        )
                        | <K_RESUMABLE> { operation = AlterSessionOperation.DISABLE_RESUMABLE; }
                        )
        )
        |
        (   
            <K_FORCE> <K_PARALLEL> ( <K_DML> { operation = AlterSessionOperation.FORCE_PARALLEL_DML; }
                                   | <K_DDL> { operation = AlterSessionOperation.FORCE_PARALLEL_DDL; }
                                   | <K_QUERY> { operation = AlterSessionOperation.FORCE_PARALLEL_QUERY; }
                                   )
        )
        |
        (   
            <K_SET> { operation = AlterSessionOperation.SET; }
        )
    )

    (   ( token = <S_CHAR_LITERAL> 
            | token = <S_IDENTIFIER>
            | token = "="
            | token = <S_LONG>
            | token = <K_PARALLEL>
            ) { parameters.add( token.image ); }
    )*


    {
        return new AlterSession(operation, parameters);
    }
}

AlterSystemStatement AlterSystemStatement():
{
    AlterSystemOperation operation = null;
    List<String> parameters = new LinkedList<String>();
}
{
    <K_ALTER> <K_SYSTEM> (
        ( 
           "ARCHIVE" "LOG" { operation = AlterSystemOperation.ARCHIVE_LOG; }
        )
        |
        ( 
            "CHECKPOINT" { operation = AlterSystemOperation.CHECKPOINT; }
        )
        |
        ( 
            "DUMP" "ACTIVE" "SESSION" "HISTORY" { operation = AlterSystemOperation.DUMP_ACTIVE_SESSION_HISTORY; }
        )
        |   
        (   
            <K_ENABLE>  ( 
                            "DISTRIBUTED RECOVERY" { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; }
                            | "RESTRICTED SESSION" { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; }
                        )
        )
        |
        (   
            <K_DISABLE> ( 
                            "DISTRIBUTED RECOVERY" { operation = AlterSystemOperation.DISABLE_DISTRIBUTED_RECOVERY; }
                            | "RESTRICTED SESSION" { operation = AlterSystemOperation.DISABLE_RESTRICTED_SESSION; }
                        )
        )
        |
        ( 
            "FLUSH" { operation = AlterSystemOperation.FLUSH; }
        )
        |
        ( 
            "DISCONNECT" "SESSION" { operation = AlterSystemOperation.DISCONNECT_SESSION; }
        )
        |
        ( 
            "KILL SESSION" { operation = AlterSystemOperation.KILL_SESSION; }
        )
        |
        ( 
            "SWITCH" { operation = AlterSystemOperation.SWITCH; }
        )
        |
        ( 
            "SUSPEND" { operation = AlterSystemOperation.SUSPEND; }
        )
        |
        ( 
            "RESUME" { operation = AlterSystemOperation.RESUME; }
        )
        |
        ( 
            "QUIESCE" "RESTRICTED" { operation = AlterSystemOperation.QUIESCE; }
        )
        |
        (
            "UNQUIESCE" { operation = AlterSystemOperation.UNQUIESCE; }
        )
        |
        ( 
            "SHUTDOWN" { operation = AlterSystemOperation.SHUTDOWN; }
        )
        |
        ( 
            "REGISTER" { operation = AlterSystemOperation.REGISTER; }
        )
        |
        ( 
            "SET" { operation = AlterSystemOperation.SET; }
        )
        |
        ( 
            "RESET" { operation = AlterSystemOperation.RESET; }
        )
    )
    parameters = captureRest()

    {
        return new AlterSystemStatement(operation, parameters);
    }
}

Wait Wait():
{
    Wait wait = new Wait();
    Token token = null;
}
{
    // sqlserver-oracle-> WAIT (TIMEOUT)
    // https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_10002.htm#i2126016
    <K_WAIT> token=<S_LONG> { wait.setTimeout(Long.parseLong(token.image)); }

    {
        return wait;
    }
}

SavepointStatement SavepointStatement():
{
  SavepointStatement savepointStatement;
}
{
  <K_SAVEPOINT> token=<S_IDENTIFIER> { savepointStatement = new SavepointStatement(token.image); }
  {
    return savepointStatement;
  }
}

RollbackStatement RollbackStatement():
{
    RollbackStatement rollbackStatement;
    boolean usingWorkKeyword=false;
    boolean usingSavepointKeyword=false;
    String savepointName=null;
    String forceDistributedTransactionIdentifier=null;
}
{
    <K_ROLLBACK> { rollbackStatement = new RollbackStatement(); }
    [ <K_WORK> { rollbackStatement.setUsingWorkKeyword(true); } ]
    [   (
            <K_TO> [ <K_SAVEPOINT> { rollbackStatement.setUsingSavepointKeyword(true); }]  
                token=<S_IDENTIFIER> { rollbackStatement.setSavepointName(token.image); }
        )
        |
        (
            <K_FORCE> token=<S_CHAR_LITERAL> { rollbackStatement.setForceDistributedTransactionIdentifier(token.image); }
        ) ]
    
    {
        return rollbackStatement;
    }
}

Commit Commit():
{
  Commit commit=new Commit();
}
{
  <K_COMMIT>
  {
    return commit;
  }
}

Comment Comment():
{
    Comment result = new Comment();
    Table table;
    Table view;
    Column column;
    Token comment;
}
{
    <K_COMMENT> <K_ON>
    (
        (
            <K_TABLE> table = Table() { result.setTable(table); }
        )
        |
        (
            <K_COLUMN> column = Column() { result.setColumn(column); }
        )
        |
        (
            <K_VIEW> view = Table() { result.setView(view); }
        )
    )
    <K_IS> comment=<S_CHAR_LITERAL> { result.setComment(new StringValue(comment.image)); }
    {
        return result;
    }
}

Grant Grant():
{
	Grant grant = new Grant();
	ArrayList<String> privileges = new ArrayList<String>();
	List<String> users;
	Token tk = null;
        List<String> objName;
}
{
	<K_GRANT>
	(
	    (
            [readGrantTypes(privileges) (<K_COMMA> readGrantTypes(privileges))*]
            <K_ON>
                (
                    objName=RelObjectNameList()   { grant.setObjectName(objName); }
                )
            )
            |
            (
                tk=<S_IDENTIFIER> { grant.setRole(tk.image); }
            )
        )
	<K_TO> (users = UsersList() {grant.setUsers(users);})
	{
            if(privileges.size() > 0) {
                grant.setPrivileges(privileges);
            }
		return grant;
	}
}

List<String> UsersList():
{
    List<String> users = new ArrayList<String>();
    String user = null;
}
{
         user=RelObjectName() { users.add(user); }
         ( "," user=ColumnsNamesListItem() { users.add(user); } )*
    {
        return users;
    }
}

void readGrantTypes(ArrayList<String> privileges):
{
}
{
    <K_SELECT> {privileges.add("SELECT");} |
    <K_INSERT> {privileges.add("INSERT");} |
    <K_UPDATE> {privileges.add("UPDATE");} |
    <K_DELETE> {privileges.add("DELETE");} |
    <K_EXECUTE> {privileges.add("EXECUTE");} |
    <K_ALTER> {privileges.add("ALTER");} |
    <K_DROP> {privileges.add("DROP");}
}

Sequence Sequence() #Sequence :
{
    List<String> data = new ArrayList<String>();
    String serverName = null, databaseName = null, schemaName = null, sequenceName = null;
}
{
    data = RelObjectNameList()
    {
        Sequence sequence = new Sequence(data);
		linkAST(sequence,jjtThis);
        return sequence;
    }
}

List<Sequence.Parameter> SequenceParameters():
{
  List<Sequence.Parameter> sequenceParameters = new ArrayList<Sequence.Parameter>();
  Sequence.Parameter parameter = null;
  Token token = null;
}
{
(
   (<K_INCREMENT> <K_BY> token=<S_LONG>
    {
        parameter = new Sequence.Parameter(Sequence.ParameterType.INCREMENT_BY);
        parameter.setValue(Long.parseLong(token.image));
        sequenceParameters.add(parameter);
    }
   )
   |
   (<K_START> <K_WITH> token=<S_LONG>
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.START_WITH);
      parameter.setValue(Long.parseLong(token.image));
      sequenceParameters.add(parameter);
    }
   )
   |
   (<K_RESTART> [<K_WITH> token=<S_LONG>]
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.RESTART_WITH);
      if(token != null){
        parameter.setValue(Long.parseLong(token.image));
      }
      sequenceParameters.add(parameter);
    }
   )
   |
   (<K_NOMAXVALUE>
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.NOMAXVALUE);
      sequenceParameters.add(parameter);
    }
    |<K_MAXVALUE> token=<S_LONG>
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.MAXVALUE);
      parameter.setValue(Long.parseLong(token.image));
      sequenceParameters.add(parameter);
    }
   )
   |
   (<K_NOMINVALUE>
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.NOMINVALUE);
      sequenceParameters.add(parameter);
    }
    |<K_MINVALUE> token=<S_LONG>
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.MINVALUE);
      parameter.setValue(Long.parseLong(token.image));
      sequenceParameters.add(parameter);
    }
   )
   |
   (<K_NOCYCLE> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.NOCYCLE)); }
    |<K_CYCLE> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.CYCLE)); }
   )
   |
   (<K_NOCACHE>
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.NOCACHE);
      sequenceParameters.add(parameter);
    }
   |<K_CACHE> token=<S_LONG>
    {
      parameter = new Sequence.Parameter(Sequence.ParameterType.CACHE);
      parameter.setValue(Long.parseLong(token.image));
      sequenceParameters.add(parameter);
    }
   )
   |
   (<K_ORDER> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.ORDER)); }
    |<K_NOORDER> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.NOORDER)); }
   )
   |
   (<K_KEEP> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.KEEP)); }
    |<K_NOKEEP> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.NOKEEP)); }
   )
   |
   (<K_SESSION> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.SESSION)); }
    |<K_GLOBAL> { sequenceParameters.add(new Sequence.Parameter(Sequence.ParameterType.GLOBAL)); }
   )
  )* //zero or many times those productions
  {
    return sequenceParameters;
  }
}

CreateSequence CreateSequence():
{
  CreateSequence createSequence = new CreateSequence();
  Sequence sequence;
  List<Sequence.Parameter> sequenceParameters;
}
{
  <K_CREATE>
  <K_SEQUENCE> sequence=Sequence() { createSequence.setSequence(sequence); }
  sequenceParameters = SequenceParameters() { sequence.setParameters(sequenceParameters); }
  {
    return createSequence;
  }
}

AlterSequence AlterSequence():
{
  AlterSequence alterSequence = new AlterSequence();
  Sequence sequence;
  List<Sequence.Parameter> sequenceParameters;
}
{
  <K_ALTER>
  <K_SEQUENCE> sequence=Sequence() { alterSequence.setSequence(sequence); }
  sequenceParameters = SequenceParameters() { sequence.setParameters(sequenceParameters); }
  {
    return alterSequence;
  }
}

CreateFunctionalStatement CreateFunctionStatement():
{
  CreateFunctionalStatement type = null;
  List<String> tokens = new LinkedList<String>();
  String statementType = null;
  boolean orReplace = false;
}
{
  <K_CREATE> [<K_OR> <K_REPLACE> { orReplace = true; } ]
  (
   <K_FUNCTION> { statementType = "FUNCTION"; }
   |
   <K_PROCEDURE> { statementType = "PROCEDURE"; }
  )
  tokens=captureRest()
  {
    if(statementType.equals("FUNCTION")) {
      type = new CreateFunction(orReplace, tokens);
    }
    if(statementType.equals("PROCEDURE")) {
      type = new CreateProcedure(orReplace, tokens);
    }

    return type;
  }
}

CreateSynonym CreateSynonym():
{
  CreateSynonym createSynonym = new CreateSynonym();
  Synonym synonym;
  boolean orReplace = false;
  boolean publicSynonym = false;
  List<String> data = new ArrayList<String>();
}
{
  <K_CREATE>
  [<K_OR> <K_REPLACE> { orReplace = true; } ]
  [<K_PUBLIC> { publicSynonym = true; } ]
  <K_SYNONYM> synonym=Synonym() { createSynonym.setSynonym(synonym); }
  <K_FOR> data = RelObjectNameList()
  {
    createSynonym.setOrReplace(orReplace);
    createSynonym.setPublicSynonym(publicSynonym);
    createSynonym.setForList(data);
    return createSynonym;
  }
}

Synonym Synonym() #Synonym :
{
    List<String> data = new ArrayList<String>();
    String serverName = null, databaseName = null, schemaName = null, sequenceName = null;
}
{
    data = RelObjectNameList()
    {
        Synonym synonym = new Synonym(data);
		linkAST(synonym,jjtThis);
        return synonym;
    }
}

UnsupportedStatement UnsupportedStatement():
{
  List<String> tokens = new LinkedList<String>();
}
{
  tokens=captureUnsupportedStatementDeclaration()
  {
    return new UnsupportedStatement(tokens);
  }
}

JAVACODE
List<String> captureRest() {
  List<String> tokens = new LinkedList<String>();
  Token tok;
  while(true) {
    tok = getToken(1);
    if(tok.kind == EOF) {
      break;
    }
    tokens.add(tok.image);
    tok = getNextToken();
  }
  return tokens;
}

JAVACODE
List<String> captureUnsupportedStatementDeclaration() {
  List<String> tokens = new LinkedList<String>();
  Token tok;

  while(true) {
    tok = getToken(1);
    if( tok.kind == EOF || tok.kind== ST_SEMICOLON || tok.kind== K_END ) {
      break;
    }
    tokens.add(tok.image);
    tok = getNextToken();
  }
  return tokens;
}