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";
    KEEP_LINE_COLUMN = true;
//  USER_CHAR_STREAM = false;
}

PARSER_BEGIN(CCJSqlParser)

package net.sf.jsqlparser.parser;

import java.lang.reflect.Field;
import java.lang.Integer;

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.database.*;
import net.sf.jsqlparser.statement.create.function.*;
import net.sf.jsqlparser.statement.create.index.*;
import net.sf.jsqlparser.statement.create.policy.*;
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.execute.*;
import net.sf.jsqlparser.statement.piped.*;
import net.sf.jsqlparser.statement.select.*;
import net.sf.jsqlparser.statement.refresh.*;
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.grant.*;
import net.sf.jsqlparser.statement.imprt.*;
import net.sf.jsqlparser.statement.export.*;
import net.sf.jsqlparser.statement.lock.*;
import java.util.*;
import java.util.AbstractMap.SimpleEntry;
import net.sf.jsqlparser.statement.select.SetOperationList.SetOperationType;

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * The parser generated by JavaCC
 */
public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
    public final static Logger LOGGER = Logger.getLogger(CCJSqlParser.class.getName());
    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;
    }

    // depth of open ClickHouse-style ternary then-branches: a ":" directly after the
    // then-branch closes the ternary and must not be taken as the JSON path operator
    private int ternaryThenBranchDepth = 0;

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

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

    private static class ObjectNames {

        private final List<String> names;
        private final List<String> delimiters;

        public ObjectNames(List<String> names, List<String> delimiters) {
            this.names = names;
            this.delimiters = delimiters;
        }

        public List<String> getNames() {
            return names;
        }

        public List<String> getDelimiters() {
            return delimiters;
        }
    }

    private static void appendWhitespaceFromTokenGap(StringBuilder buffer, Token prev, Token curr) {
        if (prev == null) return;

        int lineDiff = curr.beginLine - prev.endLine;
        if (lineDiff > 0) {
            for (int i = 0; i < lineDiff; i++) buffer.append('\n');
            for (int i = 1; i < curr.beginColumn; i++) buffer.append(' ');
        } else {
            int spaceCount = curr.beginColumn - prev.endColumn - 1;
            for (int i = 0; i < spaceCount; i++) buffer.append(' ');
        }
    }

    private static void appendTokenImageAndTrackDelimiter(StringBuilder buffer, Deque<Character> windowQueue,
                                                          int delimiterLength, String image, String tag) {
        for (char ch : image.toCharArray()) {
            buffer.append(ch);
            windowQueue.addLast(ch);
            if (windowQueue.size() > delimiterLength) {
                windowQueue.removeFirst();
            }
        }
    }

    private static boolean endsWithDelimiter(Deque<Character> windowQueue, String delimiter) {
        if (windowQueue.size() != delimiter.length()) return false;

        int i = 0;
        for (char ch : windowQueue) {
            if (ch != delimiter.charAt(i++)) return false;
        }
        return true;
    }


    /**
     * Checks whether the given token can start the operator in a RegularCondition
     * (comparison operators, JSON operators, regex operators, geometry distance, etc.)
     *
     * Used to avoid expensive syntactic lookaheads like LOOKAHEAD(RegularCondition()).
     * By the time this is called, lower-precedence operators like "-" (subtraction)
     * and "||" (concatenation) have already been consumed by SimpleExpression,
     * so seeing them here means they are comparison-level operators.
     */

    protected boolean isComparisonOperatorAhead() {
        try {
            Token token = getToken(1);
            if (token.image.equals("(") && getToken(2).image.equals("+")) {
                // Oracle (+) — only route to RegularConditionRHS if a real
                // comparison operator follows after "(" "+" ")"
                return isComparisonOperator(getToken(4));
            }
            if ("?".equals(token.image) && isTernaryAhead()) {
                // ClickHouse ternary `cond ? then : else` — the `?` must not be taken
                // as the PostgreSQL JSON operator here, it is consumed by prattExpressionRest
                return false;
            }
            return isComparisonOperator(token);
        } catch (Exception e) {
            return false;
        }
    }

    protected static boolean isComparisonOperator(Token token) {
        if (token.image == null || token.image.isEmpty()) {
            return false;
        }
        switch (token.image.charAt(0)) {
            case '>': // >, >=
            case '=': // =, =* but not => Oracle/PostgreSQL named parameter syntax
                return !token.image.equals("=>");
            case '~': // ~, ~*
                return true;
            case '<': // <, <=, <>, <@, <->, <#>, <=>, <&
                return true;
            case '*': return token.image.equals("*=");
            case '!': return token.image.startsWith("!~") || token.image.startsWith("!=");
            case '@': return token.image.equals("@@") || token.image.equals("@>");
            case '?': return true;  // ?, ?|, ?&
            case '-': return true;  // -, -#
            case '|': return token.image.equals("||");
            case '^': return token.image.startsWith("^=");
            case '&': return token.image.equals("&&") || token.image.equals("&>");
            default:  return false;
        }
    }

    /**
     * True when the pending "?" starts a ClickHouse-style ternary conditional
     * {@code cond ? then : else} rather than the PostgreSQL JSON operator:
     * a standalone ":" closes the then-branch at the same nesting depth before
     * any expression boundary (",", ";", EOF, an unbalanced closing bracket or a
     * clause keyword such as FROM/WHERE). A ":" in operand position (directly
     * after an operator) starts a JDBC named parameter instead and cannot close
     * the then-branch.
     */
    protected boolean isTernaryAhead() {
        try {
            int depth = 0;
            Token prev = null;
            for (int i = 2; ; i++) {
                Token t = getToken(i);
                if (t == null || t.kind == EOF) {
                    return false;
                }
                String image = t.image;
                if ("(".equals(image) || "[".equals(image)) {
                    depth++;
                } else if (")".equals(image) || "]".equals(image)) {
                    if (depth == 0) {
                        return false;
                    }
                    depth--;
                } else if (depth == 0) {
                    if (":".equals(image) && canEndExpression(prev)) {
                        return true;
                    }
                    if (",".equals(image) || ";".equals(image)) {
                        return false;
                    }
                    switch (t.kind) {
                        case K_SELECT: case K_FROM: case K_WHERE: case K_GROUP:
                        case K_HAVING: case K_ORDER: case K_LIMIT: case K_UNION:
                        case K_INTERSECT: case K_EXCEPT: case K_MINUS: case K_INTO:
                        case K_VALUES: case K_FETCH: case K_OFFSET:
                            return false;
                        default:
                            break;
                    }
                }
                prev = t;
            }
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * True when the token can be the LAST token of an expression: an
     * identifier, a literal, a JDBC parameter, or a balanced closing bracket.
     * Only such a token may directly precede the ":" closing the ternary
     * then-branch, since the then-branch must be a complete expression. A ":"
     * in operand position instead (directly after an operator, e.g. `x = :name`
     * or directly after the leading "?") starts a JDBC named parameter.
     * DATA_TYPE tokens end expressions as well, because a cast's target type
     * (`b :: int`) or a bare type keyword closes the then-branch. The bare "?"
     * positional parameter has no token-kind constant (anonymous token), so it
     * is recognized by its image, like the closing brackets.
     */
    private boolean canEndExpression(Token t) {
        if (t == null) {
            return false;
        }
        switch (t.kind) {
            case S_IDENTIFIER: case S_QUOTED_IDENTIFIER: case S_PARAMETER:
            case S_LONG: case S_DOUBLE: case S_HEX: case S_CHAR_LITERAL:
            case K_DATE_LITERAL: case K_DATETIMELITERAL: case DATA_TYPE:
            case K_NULL: case K_TRUE: case K_FALSE:
                return true;
            default:
                return (t.kind >= MIN_NON_RESERVED_WORD && t.kind <= MAX_NON_RESERVED_WORD)
                        || ")".equals(t.image) || "]".equals(t.image)
                        || "?".equals(t.image);
        }
    }


    /**
     * Tokens that have dedicated branches in PrimaryExpression AFTER the Function branch.
     * If isFunctionAhead() returns true for these, Function() would consume them and fail.
     */
    private boolean isNonFunctionKeyword(Token t) {
        switch (t.kind) {
            case K_CONNECT_BY_ROOT:   // CONNECT_BY_ROOT (expr)
            case K_PRIOR:             // PRIOR expr
            case K_STRUCT:            // STRUCT(...)
                return true;
            default:
                return false;
        }
    }

    /**
     * Scans ahead through a dotted identifier chain and checks if '(' follows.
     * Distinguishes function calls like func(), schema.func(), a.b.c.func()
     * from column references like col, schema.col, a.b.c.col.
     *
     * Replaces LOOKAHEAD(16) on Function() with a targeted O(chain-length) check.
     */
    protected boolean isFunctionAhead() {
      try {
        int i = 1;
        Token t = getToken(i);

        // JDBC escape function: {fn ...} — must check for FN keyword
        if (t.image.equals("{")) {
            return getToken(2).kind == K_FN;
        }

        // Optional APPROXIMATE keyword
        if (t.kind == K_APPROXIMATE) {
            i++;
            t = getToken(i);
        }

        // Exclude tokens that have their own dedicated branches
        // after Function() in PrimaryExpression
        if (isNonFunctionKeyword(t)) {
            return false;
        }

        // First token must not be a literal, bracket, or EOF
        if (t.kind == S_LONG || t.kind == S_DOUBLE || t.kind == S_HEX
                || t.kind == S_CHAR_LITERAL || t.kind == OPENING_BRACKET
                || t.kind == CLOSING_BRACKET || t.kind == EOF) {
            return false;
        }
        i++;

        // Walk through dotted name chain
        while (true) {
            t = getToken(i);
            if (t.image.equals(".") || t.image.equals("..")
                    || t.image.equals("...") || t.image.equals(":")) {
                i++;  // skip delimiter
                i++;  // skip next name part
            } else {
                break;
            }
        }

        // Must be followed by (
        if (getToken(i).kind != OPENING_BRACKET) {
            return false;
        }

        // Exclude Oracle join syntax: column(+)
        if (getToken(i + 1).image.equals("+")
                && getToken(i + 2).kind == CLOSING_BRACKET) {
            return false;
        }

        return true;
      } catch (TokenMgrException e) {
        return false;
      }
    }

    /**
     * True when the next token can only start a bare (unparenthesized) sub-select.
     *
     * Used where the alternative to Select() is an ExpressionList: the Pratt
     * arithmetic loop runs inside a Java action (prattArithRest) and JavaCC does
     * not execute actions while evaluating syntactic lookahead, so a jj_3R probe
     * cannot see through any infix operator. A syntactic LOOKAHEAD(n) over an
     * expression therefore fails as soon as an operator appears within the first
     * n tokens - e.g. "( 1 + a ) / ( 1 + b )" - and control wrongly falls through
     * to the Select() branch. This O(1) token check replaces that probe.
     */
    protected boolean isUnparenthesizedSelectAhead() {
        try {
            int kind = getToken(1).kind;
            return kind == K_SELECT || kind == K_WITH || kind == K_VALUES;
        } catch (TokenMgrException e) {
            return false;
        }
    }

    /**
     * Pratt arithmetic operator precedence loop.
     * Handles: *, /, %, ^, DIV (prec=6)  and  +, -, ||, |, &, <<, >> (prec=5)
     * Called only in real-parse mode (not syntactic-LOOKAHEAD mode) so action
     * blocks execute correctly. Safe now that no syntactic production LOOKAHEADs
     * scan through arithmetic expressions.
     */
    /**
     * Pratt boolean operator precedence loop.
     * Handles OR (prec=2), XOR (prec=3), AND/&& (prec=4).
     * Safe to use now that no syntactic production LOOKAHEADs scan through expressions.
     */
    protected Expression prattExpressionRest(Expression left, int minPrec) throws ParseException {
        while (!interrupted) {
            Token t = getToken(1);
            int op = t.kind;
            boolean ternary = "?".equals(t.image) && isTernaryAhead();
            int prec;
            if      (op == K_AND || op == OP_DOUBLEAND) prec = 4;
            else if (op == K_XOR || op == K_OR)         prec = 2;
            else if (ternary)                           prec = 2;
            else break;
            if (prec < minPrec) break;
            if (ternary) {
                // ClickHouse-style ternary conditional: cond ? then : else
                // Right-associative: both branches parse at the full expression
                // level (prec 2), nested ternaries are absorbed by the else-branch.
                jj_consume_token(op, t.image);
                Expression thenExpression;
                ternaryThenBranchDepth++;
                try {
                    thenExpression = prattExpressionRest(Condition(), 2);
                } finally {
                    ternaryThenBranchDepth--;
                }
                if (!":".equals(getToken(1).image)) {
                    throw new ParseException("Expected ':' closing the ternary conditional operator");
                }
                jj_consume_token(getToken(1).kind, getToken(1).image);
                Expression elseExpression = prattExpressionRest(Condition(), 2);
                left = new TernaryExpression(left, thenExpression, elseExpression);
                continue;
            }
            jj_consume_token(op, getToken(1).image);
            // +1 makes OR/AND/XOR left-associative
            Expression right = prattExpressionRest(Condition(), prec + 1);
            if (op == K_AND) {
                left = new AndExpression(left, right);
            } else if (op == OP_DOUBLEAND) {
                AndExpression a = new AndExpression(left, right);
                a.setUseOperator(true); left = a;
            } else if (op == K_XOR) {
                left = new XorExpression(left, right);
            } else {
                left = new OrExpression(left, right);
            }
        }
        return left;
    }

        protected Expression prattArithRest(Expression left, int minPrec) throws ParseException {
        while (!interrupted) {
            Token t = getToken(1);
            int op = t.kind;
            int prec;

            // Named tokens: OP_SLASH(/), OP_CARET(^), K_DIV, OP_CONCAT(||),
            //               OP_PIPE(|), OP_LSHIFT(<<), OP_RSHIFT(>>)
            // String-literal tokens: *, +, -, %, & (unnamed in JavaCC grammar)
            if (op == OP_SLASH || op == OP_CARET || op == K_DIV)              prec = 6;
            else if (op == OP_CONCAT || op == OP_PIPE
                  || op == OP_LSHIFT || op == OP_RSHIFT)                      prec = 5;
            else {
                // Handle unnamed tokens by image
                String img = t.image;
                if      ("*".equals(img) || "%".equals(img))                  prec = 6;
                else if ("+".equals(img) || "-".equals(img) || "&".equals(img)) prec = 5;
                else break; // not an arithmetic operator
            }

            if (prec < minPrec) break;

            // OP_PIPE: distinguish " | | " (space-sep concat) from single " | " (bitwise OR)
            if (op == OP_PIPE && getToken(2).kind == OP_PIPE) {
                jj_consume_token(OP_PIPE, getToken(1).image);
                jj_consume_token(OP_PIPE, getToken(1).image);
                Expression right = prattArithRest(PrimaryExpression(), prec + 1);
                Concat r = new Concat(); r.setLeftExpression(left); r.setRightExpression(right); left = r;
                continue;
            }

            jj_consume_token(op, getToken(1).image);
            Expression right = prattArithRest(PrimaryExpression(), prec + 1);

            if      (op == OP_SLASH)  { Division         r = new Division();         r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            else if (op == OP_CARET)  { net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            else if (op == K_DIV)     { IntegerDivision  r = new IntegerDivision();  r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            else if (op == OP_CONCAT) { Concat           r = new Concat();           r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            else if (op == OP_PIPE)   { BitwiseOr        r = new BitwiseOr();        r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            else if (op == OP_LSHIFT) { BitwiseLeftShift r = new BitwiseLeftShift(); r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            else if (op == OP_RSHIFT) { BitwiseRightShift r = new BitwiseRightShift(); r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            else {
                String img = t.image;
                if      ("*".equals(img)) { Multiplication r = new Multiplication(); r.setLeftExpression(left); r.setRightExpression(right); left = r; }
                else if ("+".equals(img)) { Addition       r = new Addition();       r.setLeftExpression(left); r.setRightExpression(right); left = r; }
                else if ("-".equals(img)) { Subtraction    r = new Subtraction();    r.setLeftExpression(left); r.setRightExpression(right); left = r; }
                else if ("%".equals(img)) { Modulo         r = new Modulo();         r.setLeftExpression(left); r.setRightExpression(right); left = r; }
                else if ("&".equals(img)) { BitwiseAnd     r = new BitwiseAnd();     r.setLeftExpression(left); r.setRightExpression(right); left = r; }
            }
        }
        return left;
    }

    // True when "(" opens a parenthesised FROM item (table/function/lateral/join)
    // rather than a SELECT subquery. Cheap 2-token check replaces expensive
    // syntactic LOOKAHEAD(ParenthesedFromItem()).
    protected boolean isParenthesedFromItemAhead() {
        try {
            if (getToken(1).kind != OPENING_BRACKET) return false;
            int k2 = getToken(2).kind;
            // Direct subquery: ( SELECT/WITH ) → ParenthesedSelect handles it
            // ( VALUES ) can be ParenthesedFromItem(Values) or ParenthesedSelect;
            // ParenthesedFromItem is checked first so Values-as-FROM-item works
            if (k2 == K_SELECT || k2 == K_WITH) return false;
            // ( ( SELECT ) UNION ( SELECT ) ) → isNestedSetOperationAhead handles it
            // Other (( patterns: ( (SELECT...) JOIN ... ) or ( (table) ) → ParenthesedFromItem
            if (k2 == K_LATERAL) return false; // handled by LateralSubSelect
            if (k2 == CLOSING_BRACKET) return false; // empty "()" is not valid
            // EXASOL: ( IMPORT ... ) is a SubImport; handled at the outer FromItem level
            // by LOOKAHEAD(2, Dialect.EXASOL...) SubImport() - must NOT go into ParenthesedFromItem
            if (k2 == K_IMPORT) return false;
            return true;
        } catch (TokenMgrException e) { return false; }
    }

    // True when ( (SELECT ...) UNION/INTERSECT/EXCEPT (SELECT ...) ) — a set-operation
    // subquery used as IN RHS. Bracket-scans past the inner select to verify a set
    // operator follows, distinguishing from comma-separated ((SELECT...), (SELECT...)).
    protected boolean isNestedSetOperationAhead() {
        try {
            if (getToken(1).kind != OPENING_BRACKET) return false;
            if (getToken(2).kind != OPENING_BRACKET) return false;
            // Skip any run of opening brackets: ( ( ( ... ( SELECT
            int i = 3;
            while (getToken(i).kind == OPENING_BRACKET) i++;
            int k = getToken(i).kind;
            if (k != K_SELECT && k != K_WITH && k != K_VALUES) return false;
            // Scan forward counting brackets to find the matching ) for token(2)
            // We are now inside all the opening brackets; depth = number of brackets skipped - 1
            // (token(1) is the outer one, token(2..i-1) are the inner ones we scanned)
            int depth = i - 2; // brackets from position 2 to i-1 inclusive
            i++;
            while (i <= 500) {
                Token t; try { t = getToken(i); } catch (TokenMgrException e) { return false; }
                if (t == null || t.kind == 0) return false;
                if (t.kind == OPENING_BRACKET) depth++;
                else if (t.kind == CLOSING_BRACKET) {
                    if (--depth == 0) break;
                }
                i++;
            }
            if (i > 500) return false;
            // Token at position i+1 follows the innermost closing )
            Token next; try { next = getToken(i + 1); } catch (TokenMgrException e) { return false; }
            if (next == null) return false;
            return next.kind == K_UNION || next.kind == K_INTERSECT ||
                   next.kind == K_EXCEPT || next.kind == K_MINUS;
        } catch (TokenMgrException e) { return false; }
    }

    protected boolean isParenthesedSelectAhead() {
        try {
            if (getToken(1).kind != OPENING_BRACKET) return false;
            int k = getToken(2).kind;
            return k == K_SELECT || k == K_WITH || k == K_VALUES;
        } catch (TokenMgrException e) {
            return false;
        }
    }

    protected boolean isImplicitCastAhead() {
        try {
            int k1 = getToken(1).kind;
            // DT_ZONE (TIMESTAMP WITH TIME ZONE / WITHOUT TIME ZONE) is also a valid
            // implicit cast type prefix handled by DataType(), but distinct from DATA_TYPE.
            if (k1 == DT_ZONE) return true;
            if (k1 != DATA_TYPE) return false;
            int k2 = getToken(2).kind;
            if (k2 != OPENING_BRACKET) return true; // DATA_TYPE literal - simple cast
            // DATA_TYPE( ... ) - precision cast if content is only S_LONG literals
            // function call otherwise (e.g. UUID(), VARCHAR(col))
            int k3 = getToken(3).kind;
            if (k3 == CLOSING_BRACKET) return false; // DATA_TYPE() - empty call
            if (k3 != S_LONG) return false;           // DATA_TYPE(expr) - function call
            int k4 = getToken(4).kind;
            if (k4 == CLOSING_BRACKET) return true;   // DATA_TYPE(N) - precision cast
            if (k4 != K_COMMA) return false;           // DATA_TYPE(N expr) - function call
            int k5 = getToken(5).kind;
            if (k5 != S_LONG) return false;            // DATA_TYPE(N, expr) - function call
            return getToken(6).kind == CLOSING_BRACKET; // DATA_TYPE(N,M) - precision cast
        } catch (TokenMgrException e) {
            return false;
        }
    }

    protected boolean isCaseExpressionAhead() {
        try {
            if (getToken(1).kind != K_CASE) return false;
            int k2 = getToken(2).kind;
            // CASE WHEN ... is unambiguously a CASE expression
            if (k2 == K_WHEN) return true;
            // CASE followed by tokens that only appear after an expression means
            // CASE is being used as a column/table name identifier
            if (k2 == K_FROM || k2 == K_WHERE || k2 == K_AS ||
                k2 == K_AND || k2 == K_OR ||
                k2 == K_IS || k2 == K_IN || k2 == K_LIKE || k2 == K_BETWEEN ||
                k2 == K_THEN || k2 == K_ELSE || k2 == K_END ||
                k2 == K_GROUP || k2 == K_ORDER || k2 == K_HAVING || k2 == K_LIMIT ||
                k2 == K_UNION || k2 == K_INTERSECT || k2 == K_EXCEPT ||
                k2 == K_OVER || k2 == CLOSING_BRACKET || k2 == 0) return false;
            // Also check single-char operator tokens by image
            Token t2 = getToken(2);
            if (t2 != null && t2.image != null) {
                String img = t2.image;
                if (img.length() == 1) {
                    char c = img.charAt(0);
                    if (c == '=' || c == '>' || c == '<' || c == '+' || c == '-' ||
                        c == '*' || c == ',' || c == '.' || c == ';') return false;
                }
            }
            // Otherwise assume it is a CASE expression with a switch value
            return true;
        } catch (TokenMgrException e) {
            return false;
        }
    }

    private boolean isKeywordArgumentAhead() {
        Token t = getToken(1);
        if (t.kind == EOF || t.image.equals(")")) return false;
        if (t.image.isEmpty() || !Character.isLetter(t.image.charAt(0))) return false;
        // S_QUOTED_IDENTIFIER is not a valid keyword arg name.
        // S_IDENTIFIER and DATA_TYPE ARE allowed — after ExpressionList has
        // consumed all comma-separated arguments, a remaining identifier or
        // type keyword before ')' is a keyword argument name (e.g.
        // PREDICTION(expr COST MODEL USING cols),
        // XMLTABLE(... COLUMNS "col" VARCHAR2(6) PATH '...')).
        if (t.kind == S_QUOTED_IDENTIFIER) return false;
        switch (t.kind) {
            case S_LONG: case S_DOUBLE: case S_HEX: case S_CHAR_LITERAL:
            case K_DISTINCT: case K_ALL: case K_UNIQUE: case K_TABLE:
            case K_ORDER: case K_ON: case K_HAVING: case K_IGNORE: case K_RESPECT:
            case K_SELECT: case K_FROM: case K_WHERE: case K_GROUP: case K_LIMIT:
            case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS:
            case K_JOIN: case K_INNER: case K_LEFT: case K_RIGHT: case K_FULL: case K_CROSS:
            case K_INTO: case K_SET: case K_FETCH: case K_OFFSET:
            case K_OVER: case K_WITHIN: case K_FILTER: case K_WITH: case K_WITHOUT:
            case K_AND: case K_OR: case K_NOT: case K_IN: case K_BETWEEN: case K_LIKE:
            case K_IS: case K_EXISTS: case K_AS:
            case K_CASE: case K_WHEN: case K_THEN: case K_ELSE: case K_END:
            case K_NULL: case K_TRUE: case K_FALSE:
            case K_RETURNING:
                return false;
        }
        Token t2 = getToken(2);
        if (t2.kind == EOF || t2.image.equals(")")) return false;
        return true;
    }

    /**
     * Scans ahead through a dotted identifier chain and checks if '*' follows.
     * Identifies table.* patterns for AllTableColumns.
     */
    protected boolean isAllTableColumnsAhead() {
        int i = 1;
        Token t = getToken(i);

        // Must start with a name-like token
        if (t.kind == S_LONG || t.kind == S_DOUBLE || t.kind == S_HEX
                || t.kind == S_CHAR_LITERAL || t.kind == OPENING_BRACKET
                || t.kind == CLOSING_BRACKET || t.kind == EOF) {
            return false;
        }
        i++;

        // Walk through dotted name chain
        while (true) {
            t = getToken(i);
            if (t.image.equals(".") || t.image.equals("..")
                    || t.image.equals("...")) {
                i++;  // skip delimiter
                i++;  // skip next part (could be "*")
            } else {
                break;
            }
        }

        // It's AllTableColumns if the chain ended on "*"
        // i.e., the last name part we skipped over was "*"
        // Back up: the last token consumed was at (i-1)
        return getToken(i - 1).image.equals("*");
    }

    /**
     * Detects PostgreSQL composite row expansion {@code (function()).*} (and any
     * number of surrounding parentheses), where a parenthesised expression wrapping
     * a single {@link Function} is immediately followed by {@code .*}.
     *
     * <p>This is a constant-time follower check (unwraps the already-parsed
     * {@code retval} and peeks the next two tokens). It deliberately avoids the
     * speculative syntactic lookahead that previously degraded performance, see
     * issue #2207.
     *
     * @param retval the expression parsed so far within the
     *        {@code ParenthesedExpressionList} branch of {@code PrimaryExpression}
     */
    protected boolean isFunctionAllColumnsAhead(Expression retval) {
        // Fast follower gate: the overwhelming majority of parenthesised
        // expressions are not followed by ".*", so reject on the token stream
        // before ever touching the already-parsed expression.
        if (!getToken(1).image.equals(".") || !getToken(2).image.equals("*")) {
            return false;
        }
        if (retval == null) {
            return false;
        }

        Expression inner = retval;
        while (inner instanceof ParenthesedExpressionList) {
            ParenthesedExpressionList<?> parenthesed = (ParenthesedExpressionList<?>) inner;
            if (parenthesed.size() != 1) {
                return false;
            }
            inner = parenthesed.get(0);
        }

        return inner instanceof Function;
    }

    /**
     * Unwraps any number of surrounding parentheses from a parenthesised
     * {@link Function} and returns the inner function. Only call this after
     * {@link #isFunctionAllColumnsAhead(Expression)} has confirmed the shape.
     */
    protected Function unwrapParenthesedFunction(Expression retval) {
        Expression inner = retval;
        while (inner instanceof ParenthesedExpressionList) {
            inner = ((ParenthesedExpressionList<?>) inner).get(0);
        }
        return (Function) inner;
    }

    /**
     * Whether the next token can continue the (possibly multi-word) keyword of
     * an OPTION query hint, e.g. any word of {@code HASH JOIN}, {@code KEEP PLAN},
     * {@code OPTIMIZE FOR UNKNOWN} or {@code IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX}.
     *
     * Reserved words usable inside hint keywords are enumerated here because
     * they cannot be matched by {@code RelObjectName()}.
     */
    private boolean isOptionHintWordAhead() {
        int kind = getToken(1).kind;
        if (kind == S_IDENTIFIER
                || (kind >= MIN_NON_RESERVED_WORD && kind <= MAX_NON_RESERVED_WORD)) {
            return true;
        }
        switch (kind) {
            case K_JOIN: case K_FOR: case K_ORDER:
            case K_UNION: case K_EXCEPT: case K_INTERSECT:
            case K_USE: case K_OPTIMIZE: case K_FORCE: case K_UNKNOWN:
                return true;
            default:
                return false;
        }
    }

    /**
     * Whether the next token can start the single value argument of an OPTION
     * query hint, e.g. the {@code 100} of {@code FAST 100} or the {@code 25}
     * of {@code MAX_GRANT_PERCENT = 25}.
     */
    private boolean isOptionHintValueAhead() {
        switch (getToken(1).kind) {
            case S_LONG: case S_DOUBLE: case S_CHAR_LITERAL:
            case S_PARAMETER:
                return true;
            default:
                return false;
        }
    }

    /**
     * Follower-based disambiguation for reserved keywords in ambiguous
     * positions (implicit alias, clause boundary, after parenthesised
     * expression, etc.).
     *
     * Checks the candidate keyword ({@code getToken(1)}) and its follower
     * ({@code getToken(2)}) to decide whether the keyword is being used as
     * an identifier or as SQL syntax.  Returns {@code true} only for
     * keywords that provably don't collide with clause syntax in the
     * current follower context.
     */
    private boolean isReservedKeywordSafeByFollower() {
        Token next2 = getToken(2);

        // If followed by . or = the keyword is a name part / property key
        if (next2.image != null
                && (next2.image.equals(".") || next2.image.equals("="))) {
            return true;
        }

        int kind = getToken(1).kind;
        int nextKind = next2.kind;

        switch (kind) {
            // Safe as implicit identifiers (no clause collision)
            case K_TABLES: case K_OPTIMIZE: case K_PUBLIC:
            case K_CASEWHEN: case K_IIF:
                return true;

            // Safe when the follower doesn't form a clause
            case K_PROCEDURE: return nextKind != K_ANALYSE;
            case K_GROUP:    return nextKind != K_BY;
            case K_ORDER:    return nextKind != K_BY && nextKind != K_SIBLINGS;
            case K_CONNECT:  return nextKind != K_BY;
            case K_START:    return nextKind != K_WITH;
            case K_LEFT:     return nextKind != K_JOIN && nextKind != K_OUTER
                                    && nextKind != K_SEMI && nextKind != K_ARRAY_LITERAL;
            case K_RIGHT:    return nextKind != K_JOIN && nextKind != K_OUTER
                                    && nextKind != K_SEMI && nextKind != K_ARRAY_LITERAL;
            case K_ARRAY_LITERAL:
                             return nextKind != K_JOIN;
            case K_ALL:      return nextKind != K_JOIN;
            case K_ANY:      return nextKind != OPENING_BRACKET;
            case K_SOME:     return nextKind != OPENING_BRACKET;
            case K_IN:       return nextKind != OPENING_BRACKET;
            case K_IF:       return nextKind != OPENING_BRACKET;
            case K_GROUPING: return nextKind != OPENING_BRACKET;
            case K_DEFAULT:  return nextKind != K_VALUES;
            case K_CREATE:   return nextKind != K_TABLE && nextKind != K_VIEW
                                    && nextKind != K_INDEX;
            case K_INTERVAL: return nextKind != S_LONG && nextKind != S_DOUBLE
                                    && nextKind != S_CHAR_LITERAL;
            case K_TOP:      return nextKind != S_LONG && nextKind != S_DOUBLE
                                    && nextKind != OPENING_BRACKET;
            case K_NEXTVAL:  return nextKind != K_VALUE;

            // IGNORE: blocks NULLS (IGNORE NULLS), FROM (DELETE IGNORE FROM),
            // INDEX (IGNORE INDEX hint)
            case K_IGNORE:   return nextKind != K_NULLS && nextKind != K_FROM
                                    && nextKind != K_INDEX;

            // GLOBAL: blocks IN (GLOBAL IN), TEMPORARY, JOIN (GLOBAL JOIN)
            case K_GLOBAL:   return nextKind != K_IN && nextKind != K_TEMPORARY
                                    && nextKind != K_JOIN;

            // Structural keywords — never safe as implicit identifiers
            case K_SET: case K_ON: case K_QUALIFY:
            case K_LIMIT: case K_OFFSET:
                return false;

            // VALUE/VALUES: safe as alias when not starting VALUES(...)
            case K_VALUE: case K_VALUES:
                return nextKind != OPENING_BRACKET && nextKind != S_IDENTIFIER
                    && nextKind != S_QUOTED_IDENTIFIER && nextKind != S_CHAR_LITERAL;

            default:
                return false;
        }
    }

    /**
     * Determines whether a reserved keyword token can be treated as an unquoted
     * identifier in the current parser position.
     *
     * Called from the semantic LOOKAHEAD inside {@code RelObjectName()}.
     * Uses the previous token to detect name positions (after structural
     * keywords, delimiters, AS), the follower token (after . or =), and
     * falls back to conservative follower-based disambiguation.
     */
    private boolean isReservedKeywordAsIdentifier() {
        Token prev = getToken(0);

        // Guard: at the very start of parsing (e.g. parseExpression()),
        // prev may be null or have null image.  This is always a name /
        // expression position, so accept any keyword.
        if (prev == null || prev.image == null) {
            return true;
        }

        // ── 1. After AS: explicit alias — accept any keyword ──────────
        if (prev.kind == K_AS) {
            return true;
        }

        // ── 2. After delimiters and operators: expression position ─────
        //    With K_FROM/K_SELECT/K_CURRENT removed from RelObjectName's
        //    token list, accepting all remaining keywords after these
        //    delimiters and operators is safe.
        if (!prev.image.isEmpty()) {
            switch (prev.image.charAt(0)) {
                // Structural delimiters
                case '.': case ',': case ':': case '(': case '=':
                // Comparison and arithmetic operators
                case '>': case '<': case '!': case '^':
                case '+': case '-': case '*': case '/': case '%':
                case '~': case '|': case '&': case '?':
                    return true;
            }
        }

        // ── 3. If followed by . or = the keyword is a name/property key ──
        Token next2 = getToken(2);
        if (next2.image != null
                && (next2.image.equals(".") || next2.image.equals("="))) {
            return true;
        }

        // ── 4. After TRULY STRUCTURAL keywords that can NEVER be ──────
        //    consumed as identifiers (i.e. they are never in our own
        //    keyword-as-identifier set).  After these, any keyword is
        //    safe as an identifier.
        //
        //    Keywords that CAN be identifiers (LEFT, LIMIT, IGNORE,
        //    etc.) are NOT listed here because they may appear as
        //    getToken(0) after being consumed as identifiers or
        //    modifiers, which is NOT a name position.
        switch (prev.kind) {
            // Boolean / conditional operators
            case K_AND: case K_OR: case K_NOT: case K_XOR:

            // Clause keywords
            case K_SELECT: case K_FROM: case K_WHERE: case K_HAVING:
            case K_INTO: case K_USING: case K_SET: case K_ON:
            case K_FETCH: case K_FOR: case K_WITH:

            // Comparison / expression operators
            case K_BETWEEN: case K_LIKE: case K_ILIKE: case K_IS:

            // Join keywords
            case K_JOIN: case K_INNER: case K_OUTER: case K_FULL:
            case K_CROSS: case K_NATURAL: case K_STRAIGHT: case K_SEMI:
            case K_LATERAL:

            // CASE/WHEN expression structure
            case K_WHEN: case K_ELSE:

            // Non-reserved keywords that structurally introduce expression
            // positions (GROUP BY expr, ORDER BY expr, CASE WHEN x THEN expr)
            case K_BY: case K_THEN:

            // Modifiers
            case K_DISTINCT: case K_DISTINCTROW:

            // Set operators
            case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS:

            // DDL / utility keywords (never identifiers)
            case K_FOREIGN: case K_CONSTRAINT: case K_UNIQUE: case K_CHECK:
            case K_FORCE:
            case K_RETURNING: case K_OUTPUT: case K_IMPORT:
            case K_PIVOT: case K_UNPIVOT:
            case K_PRIOR: case K_WINDOW: case K_ONLY:
            case K_PREFERRING: case K_PREWHERE:
            case K_RETURNS: case K_EXISTS:
            case K_QUALIFY: case K_CURRENT:
                return true;
        }

        // ── 5. Conservative default: fall back to follower check ──────
        return isReservedKeywordSafeByFollower();
    }

    /**
     * Checks whether the next token(s) can plausibly start an {@code Alias}.
     *
     * Used as a semantic LOOKAHEAD guard at alias call-sites.  Unlike
     * {@link #isReservedKeywordAsIdentifier()}, this method does NOT use
     * the structural-keyword whitelist (step 4), because an alias always
     * follows an expression — never a structural keyword in isolation.
     * Instead it goes directly to follower-based disambiguation for
     * reserved keywords.
     */
    private boolean isAliasAhead() {
        Token t = getToken(1);
        int kind = t.kind;

        // AS always starts an alias
        if (kind == K_AS) return true;

        // String-literal alias:  SELECT col 'myAlias'
        if (kind == S_CHAR_LITERAL) return true;

        // OPTION (...) introduces a query hint clause, not an alias
        if (kind == K_OPTION && getToken(2).kind == OPENING_BRACKET) {
            return false;
        }

        // For reserved keywords in alias position, skip the structural-
        // keyword whitelist and go directly to follower disambiguation.
        // Only check keywords that are actually in RelObjectName's token
        // alternatives — don't fire for brackets, operators, literals, etc.
        switch (kind) {
            case K_ALL: case K_ARRAY_LITERAL: case K_ANY: case K_CASEWHEN: case K_CONNECT:
            case K_CREATE: case K_DEFAULT:
            case K_GLOBAL: case K_GROUP: case K_GROUPING: case K_IF:
            case K_IIF: case K_IGNORE: case K_IN: case K_INTERVAL:
            case K_LEFT: case K_LIMIT: case K_NEXTVAL: case K_OFFSET:
            case K_ON: case K_OPTIMIZE: case K_ORDER: case K_PROCEDURE:
            case K_PUBLIC: case K_QUALIFY: case K_RIGHT:
            case K_SET: case K_SOME: case K_START: case K_TABLES:
            case K_TOP: case K_VALUE: case K_VALUES:
                return isReservedKeywordSafeByFollower();
            default:
                break;
        }

        // Base identifier tokens
        if (kind == S_IDENTIFIER || kind == S_QUOTED_IDENTIFIER
                || kind == DATA_TYPE || kind == K_DATETIMELITERAL
                || kind == K_DATE_LITERAL) {
            return true;
        }

        // Non-reserved keywords
        if (kind >= MIN_NON_RESERVED_WORD && kind <= MAX_NON_RESERVED_WORD) {
            return true;
        }

        return false;
    }

    /**
     * Lightweight lookahead for SpecialStringFunctionWithNamedParameters:
     * scans forward from the current position (just past the opening '(')
     * looking for FROM, IN, or PLACING at bracket nesting depth 0.
     *
     * This replaces an expensive syntactic LOOKAHEAD(NamedExpressionListExprFirst())
     * that caused exponential backtracking with deeply nested expressions.
     */
    protected boolean isNamedExprListAhead() {
        int depth = 0;
        for (int i = 1; ; i++) {
            Token t = getToken(i);
            if (t.kind == EOF) {
                return false;
            }
            if (t.kind == OPENING_BRACKET) {
                depth++;
            } else if (t.kind == CLOSING_BRACKET) {
                if (depth == 0) {
                    return false;
                }
                depth--;
            } else if (depth == 0) {
                if (t.kind == K_FROM || t.kind == K_IN || t.kind == K_PLACING) {
                    return true;
                }
                if (t.image.equals(",")) {
                    return false;
                }
            }
        }
    }

    /**
     * Checks if the next token can start a condition suffix
     * (comparison, IN, BETWEEN, LIKE, IS NULL, etc.)
     *
     * Used as the entry guard for the entire optional condition-suffix block
     * in Condition(), eliminating choice conflicts.
     */
    protected boolean isConditionSuffixAhead() {
        Token t = getToken(1);
        // Inline isComparisonOperatorAhead for single getToken(1) call
        if (t.kind == OPENING_BRACKET && getToken(2).image.equals("+")) {
            return isComparisonOperator(getToken(4));
        }
        // ClickHouse ternary `cond ? then : else` — the `?` must not be taken as the
        // PostgreSQL JSON operator, it is consumed by prattExpressionRest instead
        if ("?".equals(t.image) && isTernaryAhead()) return false;
        if (isComparisonOperator(t)) return true;
        switch (t.kind) {
            // Each suffix's start token:
            case K_OVERLAPS:          // OVERLAPS
            case K_IN:                // IN
            case K_GLOBAL:            // GLOBAL ... IN
            case K_EXCLUDES:          // EXCLUDES (...)
            case K_INCLUDES:          // INCLUDES (...)
            case K_BETWEEN:           // BETWEEN
            case K_MEMBER:            // MEMBER OF
            case K_IS:                // IS [NOT] NULL / TRUE / FALSE / UNKNOWN / DISTINCT
            case K_ISNULL:            // ISNULL
            case K_NOTNULL:           // NOTNULL
            case K_LIKE:              // LIKE
            case K_ILIKE:             // ILIKE
            case K_RLIKE:             // RLIKE
            case K_REGEXP_LIKE:       // REGEXP_LIKE
            case K_REGEXP:            // REGEXP
            case K_SIMILAR_TO:        // SIMILAR TO (in LikeExpression)
            case K_SIMILAR:           // SIMILAR TO (in SimilarToExpression)
            case K_MATCH_ANY:         // MATCH_ANY
            case K_MATCH_ALL:         // MATCH_ALL
            case K_MATCH_PHRASE:      // MATCH_PHRASE
            case K_MATCH_PHRASE_PREFIX: // MATCH_PHRASE_PREFIX
            case K_MATCH_REGEXP:      // MATCH_REGEXP
            case K_NOT:               // NOT IN / NOT BETWEEN / NOT LIKE / NOT ISNULL / NOT SIMILAR
                return true;
            // Oracle (+) before IN: col(+) IN (...)
            case OPENING_BRACKET:
                return getToken(2).image.equals("+");
            default:
                return false;
        }
    }


}

PARSER_END(CCJSqlParser)

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

    // Nesting depth for block comments: /* /* ... */ */
    int commentNesting = 0;
    // Stores the comment image up to and including the outermost */
    String storedCommentImage = null;

    // Identify the index of the quoting/escaping tokens
    public int charLiteralIndex = -1;
    public int squaredBracketOpenIndex = -1;
    {
        for (int i=0;i<CCJSqlParserConstants.tokenImage.length;i++) {
          if ( CCJSqlParserConstants.tokenImage[i].equals("<S_CHAR_LITERAL>") ) {
              charLiteralIndex = i;
              break;
          }
        }
        for (int i=0;i<CCJSqlParserConstants.tokenImage.length;i++) {
            if (CCJSqlParserConstants.tokenImage[i].equals("\"[\"")) {
                squaredBracketOpenIndex = i;
                break;
            }
        }
    }

    // Finds first occurrence of "\\'"
    public static int indexOfSequence(String s, String target) {
        int len = s.length();
        for (int i = 0; i < len - 1; i++) {
            if (s.charAt(i) == '\\' && s.charAt(i + 1) == '\'') {
                return i;
            }
        }
        return -1;
    }

    // Finds last occurrence of "\\''"
    public static int lastIndexOfSequence(String s, String target) {
        int len = s.length();
        for (int i = len - 3; i >= 0; i--) {
            if (s.charAt(i) == '\\' && s.charAt(i + 1) == '\'' && s.charAt(i + 2) == '\'') {
                return i;
            }
        }
        return -1;
    }

    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;
	}

    private static boolean endsWithDelimiter(Deque<Character> windowQueue, String delimiter) {
        if (windowQueue.size() != delimiter.length()) {
            return false;
        }

        int i = 0;
        for (char ch : windowQueue) {
            if (ch != delimiter.charAt(i++)) {
                return false;
            }
        }
        return true;
    }

    public void consumeDollarQuotedString(String closingQuote) {
        Deque<Character> windowQueue = new ArrayDeque<Character>();
        int delimiterLength = closingQuote.length();

        try {
            while (true) {
                char ch = input_stream.readChar();
                windowQueue.addLast(ch);
                if (windowQueue.size() > delimiterLength) {
                    windowQueue.removeFirst();
                }
                if (endsWithDelimiter(windowQueue, closingQuote)) {
                    return;
                }
            }
        } catch (java.io.IOException e) {
            reportError(Math.max(closingQuote.length(), input_stream.GetImage().length()));
        }
    }
}

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

// Sentinel: start of non-reserved keyword range (for O(1) identifier checks)
<UNREACHABLE>SKIP:
{
    <MIN_NON_RESERVED_WORD: "MIN NON RESERVED WORD">
}

/**
 * Non-reserved SQL keywords usable as unquoted identifiers.
 * Tokens are declared inline to get consecutive kind values between
 * MIN_NON_RESERVED_WORD and MAX_NON_RESERVED_WORD sentinels.
 */
String NonReservedWord() :
{    Token tk = null; }
{
    (
        tk=<K_ACTION: "ACTION">
      | tk=<K_ACTIVE: "ACTIVE">
      | tk=<K_ADD:"ADD">
      | tk=<K_ADVANCE:"ADVANCE">
      | tk=<K_ADVISE:"ADVISE">
      | tk=<K_AGAINST:"AGAINST">
      | tk=<K_AGGREGATE: "AGGREGATE">
      | tk=<K_ALGORITHM: "ALGORITHM">
      | tk=<K_ALIGN:"ALIGN">
      | tk=<K_ALTER:"ALTER">
      | tk=<K_ALWAYS:"ALWAYS">
      | tk=<K_ANALYSE:"ANALYSE">
      | tk=<K_ANALYZE:"ANALYZE">
      | tk=<K_APPEND_ONLY:"APPEND_ONLY">
      | tk=<K_APPLY:"APPLY">
      | tk=<K_APPROXIMATE:"APPROXIMATE">
      | tk=<K_ARCHIVE: "ARCHIVE">
      | tk=<K_ARRAY_LITERAL: "ARRAY" >
      | tk=<K_ASYMMETRIC: "ASYMMETRIC">
      | tk=<K_AT: "AT">
      | tk=<K_ASC:"ASC">
      | tk=<K_AUTHORIZATION:"AUTHORIZATION">
      | tk=<K_AUTO:"AUTO">
      | tk=<K_AUTO_INCREMENT:"AUTO_INCREMENT">
      | tk=<K_AZURE:"AZURE">
      | tk=<K_BASE64:"BASE64">
      | tk=<K_BEFORE: "BEFORE">
      | tk=<K_BEGIN:"BEGIN">
      | tk=<K_BERNOULLI: "BERNOULLI">
      | tk=<K_BINARY: "BINARY">
      | tk=<K_BIT:"BIT">
      | tk=<K_BLOBSTORAGE:"BLOBSTORAGE">
      | tk=<K_BLOCK: "BLOCK">
      | tk=<K_BOOLEAN:"BOOLEAN">
      | tk=<K_BREADTH:"BREADTH">
      | tk=<K_BRANCH:"BRANCH">
      | tk=<K_BROWSE:"BROWSE">
      | tk=<K_BY:"BY">
      | tk=<K_BYTES: "BYTES">
      | tk=<K_CACHE: "CACHE">
      | tk=<K_BUFFERS: "BUFFERS">
      | tk=<K_BYTE: "BYTE">
      | tk=<K_CALL : "CALL">
      | tk=<K_CASCADE: "CASCADE">
      | tk=<K_CASE:"CASE">
      | tk=<K_CAST: "CAST">
      | tk=<K_CERTIFICATE: "CERTIFICATE">
      | tk=<K_CHARACTER:"CHARACTER">
      | tk=<K_CHANGE:"CHANGE">
      | tk=<K_CHANGES:"CHANGES">
      | tk=<K_CHECKPOINT:"CHECKPOINT">
      | tk=<K_CHAR:"CHAR">
      | tk=<K_CLOSE:"CLOSE">
      | tk=<K_CLOUD:"CLOUD">
      | tk=<K_COALESCE:"COALESCE">
      | tk=<K_COLLATE:"COLLATE">
      | tk=<K_COLUMN:"COLUMN">
      | tk=<K_COLUMNS:"COLUMNS">
      | tk=<K_COMMIT:"COMMIT">
      | tk=<K_COMMENT:"COMMENT">
      | tk=<K_COMMENTS:"COMMENTS">
      | tk=<K_CONFLICT:"CONFLICT">
      | tk=<K_CONSTRAINTS:"CONSTRAINTS">
      | tk=<K_CONVERT:"CONVERT">
      | tk=<K_CORRESPONDING:"CORRESPONDING">
      | tk=<K_COSTS: "COSTS">
      | tk=<K_COUNT: "COUNT">
      | tk=<K_CREATED:"CREATED">
      | tk=<K_CYCLE:"CYCLE">
      | tk=<K_DATABASE:"DATABASE">
      | tk=<K_DATA:"DATA">
      | tk=<K_DECLARE: "DECLARE">
      | tk=<K_DBA_RECYCLEBIN: "DBA_RECYCLEBIN">
      | tk=<K_DEFAULTS: "DEFAULTS">
      | tk=<K_DEPTH: "DEPTH">
      | tk=<K_DEFERRABLE : "DEFERRABLE">
      | tk=<K_DELAYED : "DELAYED">
      | tk=<K_DELETE:"DELETE">
      | tk=<K_DELIMIT : "DELIMIT">
      | tk=<K_DELIMITER : "DELIMITER">
      | tk=<K_DESC:"DESC">
      | tk=<K_DESCRIBE:"DESCRIBE">
      | tk=<K_DISABLE : "DISABLE">
      | tk=<K_DISCARD : "DISCARD">
      | tk=<K_DISCONNECT:"DISCONNECT">
      | tk=<K_DIV:"DIV">
      | tk=<K_DDL:"DDL">
      | tk=<K_DML:"DML">
      | tk=<K_DO:"DO">
      | tk=<K_DOMAIN:"DOMAIN">
      | tk=<K_DRIVER:"DRIVER">
      | tk=<K_DROP:"DROP">
      | tk=<K_DUMP:"DUMP">
      | tk=<K_DUMPFILE:"DUMPFILE">
      | tk=<K_DUPLICATE: "DUPLICATE">
      | tk=<K_ELEMENTS: "ELEMENTS">
      | tk=<K_ENCLOSED: "ENCLOSED">
      | tk=<K_EMIT: "EMIT">
      | tk=<K_EMPTY: "EMPTY">
      | tk=<K_ENABLE: "ENABLE">
      | tk=<K_ENCODING: "ENCODING">
      | tk=<K_ENCRYPTION: "ENCRYPTION">
      | tk=<K_END: "END">
      | tk=<K_ESCAPED: "ESCAPED">
      | tk=<K_ENFORCED: "ENFORCED">
      | tk=<K_ENGINE: "ENGINE">
      | tk=<K_ERROR: "ERROR">
      | tk=<K_ESCAPE: "ESCAPE">
      | tk=<K_EXA: "EXA">
      | tk=<K_EXCHANGE: "EXCHANGE">
      | tk=<K_EXCLUDE: "EXCLUDE">
      | tk=<K_EXCLUDING: "EXCLUDING">
      | tk=<K_EXCLUSIVE: "EXCLUSIVE">
      | tk=<K_EXEC: "EXEC">
      | tk=<K_EXECUTE: "EXECUTE">
      | tk=<K_EXPLAIN:"EXPLAIN">
      | tk=<K_EXPLICIT:"EXPLICIT">
      | tk=<K_EXTENDED:"EXTENDED">
      | tk=<K_EXTRACT:"EXTRACT">
      | tk=<K_EXPORT:"EXPORT">
      | tk=<K_ISOLATION:("UR" | "RS" | "RR" | "CS")>
      | tk=<K_FILTER: "FILTER">
      | tk=<K_FIELDS: "FIELDS">
      | tk=<K_FILL: "FILL">
      | tk=<K_FIRST: "FIRST">
      | tk=<K_FLUSH: "FLUSH">
      | tk=<K_FOLLOWING: "FOLLOWING">
      | tk=<K_FORMAT:"FORMAT">
      | tk=<K_FULLTEXT:"FULLTEXT">
      | tk=<K_FUNCTION:"FUNCTION">
      | tk=<K_GRANT:"GRANT">
      | tk=<K_GROUPS:"GROUPS">
      | tk=<K_GROUP_CONCAT:"GROUP_CONCAT">
      | tk=<K_GUARD:"GUARD">
      | tk=<K_HASH:"HASH">
      | tk=<K_HIGH : "HIGH">
      | tk=<K_HIGH_PRIORITY : "HIGH_PRIORITY">
      | tk=<K_HISTORY : "HISTORY">
      | tk=<K_HOPPING:"HOPPING">
      | tk=<K_IDENTIFIED:"IDENTIFIED">
      | tk=<K_IDENTITY:"IDENTITY">
      | tk=<K_INCLUDE:"INCLUDE">
      | tk=<K_INCLUDE_NULL_VALUES:"INCLUDE_NULL_VALUES">
      | tk=<K_INCLUDING:"INCLUDING">
      | tk=<K_INCREMENT:"INCREMENT">
      | tk=<K_INDEX: "INDEX">
      | tk=<K_INFORMATION: "INFORMATION">
      | tk=<K_INSERT:"INSERT">
      | tk=<K_INTERLEAVE: "INTERLEAVE">
      | tk=<K_INTERPOLATE: "INTERPOLATE">
      | tk=<K_INTERPRET: "INTERPRET">
      | tk=<K_INVALIDATE:"INVALIDATE">
      | tk=<K_INVERSE:"INVERSE">
      | tk=<K_INVISIBLE:"INVISIBLE">
      | tk=<K_ISNULL:"ISNULL">
      | tk=<K_JDBC:"JDBC">
      | tk=<K_JSON:"JSON">
      | tk=<K_JSON_OBJECT: "JSON_OBJECT">
      | tk=<K_JSON_OBJECTAGG: "JSON_OBJECTAGG">
      | tk=<K_JSON_ARRAY: "JSON_ARRAY">
      | tk=<K_JSON_ARRAYAGG: "JSON_ARRAYAGG">
      | tk=<K_KEEP:"KEEP">
      | tk=<K_KEY_BLOCK_SIZE: "KEY_BLOCK_SIZE">
      | tk=<K_KEY:"KEY">
      | tk=<K_KEYS:"KEYS">
      | tk=<K_KILL:"KILL">
      | tk=<K_FN:"FN">
      | tk=<K_LAST: "LAST">
      | tk=<K_LEADING:"LEADING">
      | tk=<K_LESS:"LESS">
      | tk=<K_LEVEL:"LEVEL">
      | tk=<K_LINES:"LINES">
      | tk=<K_LOCAL:"LOCAL">
      | tk=<K_LOCK:"LOCK">
      | tk=<K_LOCKED:"LOCKED">
      | tk=<K_LINK:"LINK">
      | tk=<K_LOG:"LOG">
      | tk=<K_LOOP:"LOOP">
      | tk=<K_LOW : "LOW">
      | tk=<K_LOW_PRIORITY : "LOW_PRIORITY">
      | tk=<K_LTRIM : "LTRIM">
      | tk=<K_MATCH: "MATCH">
      | tk=<K_MATCH_ANY: "MATCH_ANY">
      | tk=<K_MATCH_ALL: "MATCH_ALL">
      | tk=<K_MATCH_PHRASE: "MATCH_PHRASE">
      | tk=<K_MATCH_PHRASE_PREFIX: "MATCH_PHRASE_PREFIX">
      | tk=<K_MATCH_REGEXP: "MATCH_REGEXP">
      | tk=<K_MATCHED: "MATCHED">
      | tk=<K_MATERIALIZED:"MATERIALIZED">
      | tk=<K_MAX: "MAX">
      | tk=<K_MAXVALUE: "MAXVALUE">
      | tk=<K_MEMBER: "MEMBER">
      | tk=<K_MERGE: "MERGE">
      | tk=<K_MIN:"MIN">
      | tk=<K_MINVALUE:"MINVALUE">
      | tk=<K_MODE: "MODE">
      | tk=<K_MODIFY: "MODIFY">
      | tk=<K_MOVEMENT: "MOVEMENT">
      | tk=<K_NAMES:"NAMES">
      | tk=<K_NAME:"NAME">
      | tk=<K_NEVER:"NEVER">
      | tk=<K_NEXT:"NEXT">
      | tk=<K_NEXTVAL: (  (("NEXTVAL")((" ")+("FOR"))?)  |  ( ("NEXT")(" ")+("VALUE") (" ")+("FOR") )  )>
      | tk=<K_NO:"NO">
      | tk=<K_NOCACHE:"NOCACHE">
      | tk=<K_NOKEEP:"NOKEEP">
      | tk=<K_NOLOCK:"NOLOCK">
      | tk=<K_NOMAXVALUE:"NOMAXVALUE">
      | tk=<K_NOMINVALUE:"NOMINVALUE">
      | tk=<K_NONE:"NONE">
      | tk=<K_NOORDER:"NOORDER">
      | tk=<K_NOTHING:"NOTHING">
      | tk=<K_NOTNULL:"NOTNULL">
      | tk=<K_NOVALIDATE : "NOVALIDATE">
      | tk=<K_NULLS: "NULLS">
      | tk=<K_NOWAIT: "NOWAIT">
      | tk=<K_OF:"OF">
      | tk=<K_OFF:"OFF">
      | tk=<K_OPTION: "OPTION">
      | tk=<K_OPTIONALLY:"OPTIONALLY">
      | tk=<K_OPEN:"OPEN">
      | tk=<K_ORA: "ORA">
      | tk=<K_ORDINALITY:"ORDINALITY">
      | tk=<K_OUTFILE:"OUTFILE">
      | tk=<K_OVER:"OVER">
      | tk=<K_OVERFLOW:"OVERFLOW">
      | tk=<K_OVERLAPS:"OVERLAPS">
      | tk=<K_OVERRIDING:"OVERRIDING">
      | tk=<K_OVERWRITE:"OVERWRITE">
      | tk=<K_PADDING:"PADDING">
      | tk=<K_PARALLEL:"PARALLEL">
      | tk=<K_PARENT:"PARENT">
      | tk=<K_PARSER: "PARSER">
      | tk=<K_PARTITION:"PARTITION">
      | tk=<K_PARTITIONING:"PARTITIONING">
      | tk=<K_PATH:"PATH">
      | tk=<K_PERCENT:"PERCENT">
      | tk=<K_PLACING:"PLACING">
      | tk=<K_PLAN:"PLAN">
      | tk=<K_PLUS:"PLUS">
      | tk=<K_PRECEDING: "PRECEDING">
      | tk=<K_PRIMARY:"PRIMARY">
      | tk=<K_POLICY:"POLICY">
      | tk=<K_PURGE:"PURGE">
      | tk=<K_QUERY:"QUERY">
      | tk=<K_QUICK : "QUICK">
      | tk=<K_QUIESCE: "QUIESCE">
      | tk=<K_RANGE: "RANGE">
      | tk=<K_RAW: "RAW">
      | tk=<K_READ: "READ" >
      | tk=<K_REBUILD: "REBUILD">
      | tk=<K_RECYCLEBIN: "RECYCLEBIN">
      | tk=<K_RECURSIVE:"RECURSIVE">
      | tk=<K_REFERENCES:"REFERENCES">
      | tk=<K_REFRESH:"REFRESH">
      | tk=<K_REGEXP: "REGEXP">
      | tk=<K_REJECT: "REJECT">
      | tk=<K_RESPECT: "RESPECT">
      | tk=<K_RLIKE: "RLIKE">
      | tk=<K_REGEXP_LIKE: "REGEXP_LIKE">
      | tk=<K_REGISTER: "REGISTER">
      | tk=<K_REMOTE: "REMOTE">
      | tk=<K_REMOVE: "REMOVE">
      | tk=<K_RENAME:"RENAME">
      | tk=<K_REORGANIZE: "REORGANIZE">
      | tk=<K_REPAIR: "REPAIR">
      | tk=<K_REPEATABLE: "REPEATABLE">
      | tk=<K_REPLACE:"REPLACE">
      | tk=<K_RESET:"RESET">
      | tk=<K_RESTART:"RESTART">
      | tk=<K_RESUMABLE: "RESUMABLE">
      | tk=<K_RESUME: "RESUME">
      | tk=<K_RESTRICT: "RESTRICT">
      | tk=<K_RESTRICTED: "RESTRICTED">
      | tk=<K_RETURN: "RETURN">
      | tk=<K_ROLLBACK:"ROLLBACK">
      | tk=<K_ROLLUP:"ROLLUP">
      | tk=<K_ROOT:"ROOT">
      | tk=<K_ROW: "ROW">
      | tk=<K_ROWS: "ROWS">
      | tk=<K_RTRIM: "RTRIM">
      | tk=<K_SAFE_CAST: "SAFE_CAST">
      | tk=<K_SAFE_CONVERT: "SAFE_CONVERT">
      | tk=<K_SAVEPOINT: "SAVEPOINT">
      | tk=<K_SCHEMA: "SCHEMA">
      | tk=<K_SEARCH:"SEARCH">
      | tk=<K_SECURE: "SECURE">
      | tk=<K_SECURITY:"SECURITY">
      | tk=<K_SEED: "SEED">
      | tk=<K_SEQUENCE: "SEQUENCE">
      | tk=<K_SEPARATOR:"SEPARATOR">
      | tk=<K_SESSION:"SESSION">
      | tk=<K_SETS:"SETS">
      | tk=<K_SHOW : "SHOW">
      | tk=<K_SHUTDOWN : "SHUTDOWN">
      | tk=<K_SHARE : "SHARE">
      | tk=<K_SIBLINGS:"SIBLINGS">
      | tk=<K_SIMILAR:"SIMILAR">
      | tk=<K_SIZE:"SIZE">
      | tk=<K_SKIP: "SKIP">
      | tk=<K_SPATIAL:"SPATIAL">
      | tk=<K_STALENESS: "STALENESS">
      | tk=<K_STARTING:"STARTING">
      | tk=<K_STEP: "STEP">
      | tk=<K_STORED: "STORED">
      | tk=<K_STREAM: "STREAM">
      | tk=<K_STRICT: "STRICT">
      | tk=<K_STRING: "STRING">
      | tk=<K_STRUCT: "STRUCT">
      | tk=<K_SUMMARIZE: "SUMMARIZE">
      | tk=<K_SUSPEND:"SUSPEND">
      | tk=<K_SWITCH: "SWITCH">
      | tk=<K_SYMMETRIC:"SYMMETRIC">
      | tk=<K_SYNONYM:"SYNONYM">
      | tk=<K_SYSTEM:"SYSTEM">
      | tk=<K_SYSTEM_TIME:"SYSTEM_TIME">
      | tk=<K_SYSTEM_TIMESTAMP:"SYSTEM_TIMESTAMP">
      | tk=<K_SYSTEM_VERSION:"SYSTEM_VERSION">
      | tk=<K_TABLE:"TABLE">
      | tk=<K_TABLESPACE: "TABLESPACE">
      | tk=<K_TERMINATED:"TERMINATED">
      | tk=<K_TRIGGER: "TRIGGER">
      | tk=<K_THEN:"THEN">
      | tk=<K_TEMP:"TEMP">
      | tk=<K_TEXT_LITERAL: "TEXT" | "TINYTEXT" | "MEDIUMTEXT" | "LONGTEXT" >
      | tk=<K_TEMPORARY:"TEMPORARY">
      | tk=<K_THAN:"THAN">
      | tk=<K_TIME_KEY_EXPR : ( ("CURRENT" ( "_" | (" ")+ ) "TIMESTAMP") | ("CURRENT" ( "_" | (" ")+ ) "TIME") | ("CURRENT" ( "_" | (" ")+ ) "DATE") | ("CURRENT" ( "_" | (" ")+ ) "TIMEZONE") ) ( "()" )?>
      | tk=<K_TIMEOUT:"TIMEOUT">
      | tk=<K_TO:"TO">
      | tk=<K_TRIM:"TRIM">
      | tk=<K_TRUNCATE:"TRUNCATE">
      | tk=<K_TRY_CAST: "TRY_CAST">
      | tk=<K_TRY_CONVERT: "TRY_CONVERT">
      | tk=<K_TUMBLING:"TUMBLING">
      | tk=<K_TYPE:"TYPE">
      | tk=<K_UNLIMITED: "UNLIMITED">
      | tk=<K_UNLOGGED: "UNLOGGED">
      | tk=<K_UPDATE:"UPDATE">
      | tk=<K_UPSERT:"UPSERT">
      | tk=<K_UNQIESCE:"UNQIESCE">
      | tk=<K_USER:"USER">
      | tk=<K_SIGNED:"SIGNED">
      | tk=<K_STRING_FUNCTION_NAME: ("SUBSTR" | "SUBSTRING" | "TRIM" | "POSITION" | "OVERLAY")>
      | tk=<K_UNSIGNED:"UNSIGNED">
      | tk=<K_VALIDATE : "VALIDATE">
      | tk=<K_VALIDATION: "VALIDATION">
      | tk=<K_VERBOSE: "VERBOSE">
      | tk=<K_VERSION: "VERSION">
      | tk=<K_VIEW:"VIEW">
      | tk=<K_VISIBLE: "VISIBLE">
      | tk=<K_VOLATILE:"VOLATILE">
      | tk=<K_CONCURRENTLY:"CONCURRENTLY">
      | tk=<K_WAIT : "WAIT">
      | tk=<K_WITH_TIES:"WITH TIES">
      | tk=<K_WITHIN:"WITHIN">
      | tk=<K_WITHOUT:"WITHOUT">
      | tk=<K_WITHOUT_ARRAY_WRAPPER:"WITHOUT_ARRAY_WRAPPER">
      | tk=<K_WORK:"WORK">
      | tk=<K_XML:"XML">
      | tk=<K_XMLAGG:"XMLAGG">
      | tk=<K_XMLDATA:"XMLDATA">
      | tk=<K_XMLSCHEMA:"XMLSCHEMA">
      | tk=<K_XMLTEXT:"XMLTEXT">
      | tk=<K_XSINIL:"XSINIL">
      | tk=<K_YAML:"YAML">
      | tk=<K_YES:"YES">
      | tk=<K_ZONE:"ZONE">
    )
    { return tk.image; }
}

// Sentinel: end of non-reserved keyword range
<UNREACHABLE>SKIP:
{
    <MAX_NON_RESERVED_WORD: "MAX NON RESERVED WORD">
}

TOKEN: /* Reserved SQL Keywords and structural tokens */
{
    <K_AT_SIGN: "@">
|   <K_AT_V: "@V">
|   <K_ABSENT: "ABSENT">
|   <K_ALL:"ALL">
|   <K_AND:"AND">
|   <K_ANY:"ANY">
|   <K_AS: "AS">
|   <K_BETWEEN:"BETWEEN">
|   <K_BOTH:"BOTH">
|   <K_CASEWHEN:"CASEWHEN">  /* H2 casewhen function */
|   <K_CHECK:"CHECK">
|   <K_COMMA: ",">
|   <K_CONNECT:"CONNECT">
|   <K_CONNECT_BY_ROOT: "CONNECT_BY_ROOT">
|   <K_CONSTRAINT:"CONSTRAINT">
|   <K_CREATE:"CREATE">
|   <K_CROSS:"CROSS">
|   <K_CSV:"CSV">
|   <K_CURRENT: "CURRENT">
|   <K_DATETIMELITERAL : "DATE" | "DATETIME" | "TIME" | "TIMESTAMP" | "TIMESTAMPTZ" >
|   <K_DATE_LITERAL : "YEAR" | "MONTH" | "DAY" | "HOUR" | "MINUTE" | "SECOND" >
|   <K_DEFAULT : "DEFAULT">
|   <K_DISTINCT:"DISTINCT">
|   <K_DISTINCTROW:"DISTINCTROW">
|   <K_ELSE:"ELSE">
|   <K_ERRORS: "ERRORS">
|   <K_EXCEPT: "EXCEPT">
|   <K_EXCLUDES: "EXCLUDES"> /* Salesforce SOQL */
|   <K_EXISTS:"EXISTS">
|   <K_EXTEND:"EXTEND">
|   <K_FBV:"FBV">
|   <K_FETCH:"FETCH">
|   <K_FILE: "FILE">
|   <K_FINAL: "FINAL">
|   <K_FALSE: "FALSE">
|   <K_FOR:"FOR">
|   <K_FORCE : "FORCE">
|   <K_FOREIGN:"FOREIGN">
|   <K_FROM:"FROM">
|   <K_FULL:"FULL">
|   <K_GLOBAL:"GLOBAL">
|   <K_GROUP:"GROUP">
|   <K_GROUPING:"GROUPING">
|   <K_HAVING:"HAVING">
|   <K_IF:"IF">
|   <K_IIF:"IIF">
|   <K_IGNORE : "IGNORE">
|   <K_ILIKE:"ILIKE">
|   <K_IMPORT:"IMPORT">
|   <K_IN:"IN">
|   <K_INCLUDES:"INCLUDES"> /* Salesforce SOQL */
|   <K_INNER:"INNER">
|   <K_STATEMENT:"STATEMENT">
|   <K_STRAIGHT:"STRAIGHT_JOIN">
|   <K_INTERSECT:"INTERSECT">
|   <K_INTERVAL:"INTERVAL">
|   <K_INTO:"INTO">
|   <K_IS:"IS">
|   <K_JOIN:"JOIN">
|   <K_LATERAL:"LATERAL">
|   <K_LEFT:"LEFT">
|   <K_LIKE:"LIKE">
|   <K_LIMIT:"LIMIT">
|   <K_MINUS:"MINUS">
|   <K_NATURAL:"NATURAL">
|   <K_NOCYCLE:"NOCYCLE">
|   <K_NOT:"NOT">
|   <K_NULL:"NULL">
|   <K_OFFSET:"OFFSET">
|   <K_ON:"ON">
|   <K_ONLY:"ONLY">
|   <K_OR:"OR">
|   <K_ORACLE_NAMED_PARAMETER_ASSIGNMENT: "=>">
|   <K_POSTGRES_NAMED_PARAMETER_ASSIGNMENT: ":=">
|   <K_ORDER:"ORDER">
|   <K_OUTER:"OUTER">
|   <K_OUTPUT:"OUTPUT">
|   <K_OPTIMIZE: "OPTIMIZE" >
|   <K_PIVOT:"PIVOT">
|   <K_PREFERRING: "PREFERRING">
|   <K_PREWHERE: "PREWHERE">
|   <K_PRIOR:"PRIOR">
|   <K_PROCEDURE:"PROCEDURE">
|   <K_PUBLIC:"PUBLIC">
|   <K_QUALIFY: "QUALIFY">
|   <K_RETURNS: "RETURNS">
|   <K_RETURNING: "RETURNING">
|   <K_RIGHT:"RIGHT">
|   <K_SAMPLE: "SAMPLE">
|   <K_SCRIPT: "SCRIPT">
|   <K_SELECT: ("SELECT" | "SEL")>
|   <K_SEMI : "SEMI">
|   <K_SET:"SET">
|   <K_SETTINGS:"SETTINGS">
|   <K_SOME:"SOME">
|   <K_START:"START">
|   <K_TABLES:"TABLES">
|   <K_TABLESAMPLE: "TABLESAMPLE">
|   <K_TOP:"TOP">
|   <K_TRAILING:"TRAILING">
|   <K_TRUE:"TRUE">
|   <K_UNBOUNDED: "UNBOUNDED">
|   <K_UNION:"UNION">
|   <K_UNIQUE:"UNIQUE">
|   <K_UNKNOWN:"UNKNOWN">
|   <K_UNPIVOT:"UNPIVOT">
|   <K_USE:"USE">
|   <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_VALUE:"VALUE">
|   <K_VALUES:"VALUES">
|   <K_VERIFY: "VERIFY">
|   <K_WHEN:"WHEN">
|   <K_WHERE:"WHERE">
|   <K_WINDOW:"WINDOW">
|   <K_WITH:"WITH">
|   <K_XOR:"XOR">
|   <K_XMLSERIALIZE:"XMLSERIALIZE">
|   <OPENING_BRACKET: "("> |   <CLOSING_BRACKET: ")">
|   <OPENING_CURLY_BRACKET: "{">
|   <CLOSING_CURLY_BRACKET: "}">
|   <DOUBLE_COLON: ":">
|   <K_SIMILAR_TO: ( <K_SIMILAR> (" ")+ <K_TO> ) >
}

TOKEN : /* Statement Separators */
{
    <ST_SEMICOLON : ( ";" | ("\n\n\n") | "\n/\n" | "\ngo\n" ) >
}

TOKEN : /* Operators */
{
    <OP_GREATERTHANEQUALS: ">" (<WHITESPACE>)* "=">
|   <OP_COSINESIMILARITY: "<=>">
|   <OP_MINORTHANEQUALS: "<" (<WHITESPACE>)* "=">
|   <OP_NOTEQUALSSTANDARD: "<" (<WHITESPACE>)* ">">
|   <OP_NOTEQUALSBANG: "!" (<WHITESPACE>)* "=">
|   <OP_NOTEQUALSHAT: "^=">
|   <OP_CONCAT: "||">
|   <OP_PIPE: "|">
|   <OP_CARET: "^">
|   <OP_SLASH: "/">
|   <OP_LSHIFT: "<<">
|   <OP_RSHIFT: ">>">
| 	<OP_DOUBLEAND: "&&">
| 	<OP_CONTAINS: "&>">
| 	<OP_CONTAINEDBY: "<&">
}

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 : /* Data Types */
{
    <DATA_TYPE: ( <TYPE_BIT> | <TYPE_BLOB> | <TYPE_BOOLEAN> |  <TYPE_ENUM>
                     | <TYPE_REAL> | <TYPE_DOUBLE> | <TYPE_UUID> | <TYPE_MAP>| <TYPE_TINYINT> | <TYPE_SMALLINT>
                     | <TYPE_INTEGER> | <TYPE_BIGINT> | <TYPE_HUGEINT> | <TYPE_UTINYINT> | <TYPE_USMALLINT>
                     | <TYPE_UINTEGER> | <TYPE_UBIGINT> | <TYPE_UHUGEINT> | <TYPE_DECIMAL>
                     | <TYPE_VARCHAR> | <TYPE_TIME> | <TYPE_TIMESTAMP>
              ) >

    | <#TYPE_BIT:  "BISTRING">
    | <#TYPE_BLOB: "BLOB" | "BYTEA" | <K_BINARY> | "VARBINARY" | <K_BYTES> >
    | <#TYPE_BOOLEAN: <K_BOOLEAN> | "BOOL" >
    | <#TYPE_CLOB: "CLOB">
    | <#TYPE_ENUM: "ENUM" >
    | <#TYPE_MAP: "MAP" >
    | <#TYPE_DECIMAL: "DECIMAL" | "NUMBER" | "NUMERIC" >
    | <#TYPE_TINYINT: "TINYINT" | "INT1" >
    | <#TYPE_SMALLINT: "SMALLINT" | "INT2" | "SHORT" >
    | <#TYPE_INTEGER: ( "INTEGER" | "INT" | "INT4" | <K_SIGNED> | <K_UNSIGNED> ) >
    | <#TYPE_BIGINT: "BIGINT" | "INT8" | "LONG" >
    | <#TYPE_HUGEINT: "HUGEINT" >
    | <#TYPE_UTINYINT: "UTINYINT" >
    | <#TYPE_USMALLINT: "USMALLINT" >
    | <#TYPE_UINTEGER: "UINTEGER" >
    | <#TYPE_UBIGINT: "UBIGINT" >
    | <#TYPE_UHUGEINT: "UHUGEINT" >
    | <#TYPE_REAL: "REAL" | "FLOAT4" | "FLOAT">
    | <#TYPE_DOUBLE: "DOUBLE" | "PRECISION"  | "FLOAT8" | "FLOAT64">
    | <#TYPE_VARCHAR: "NVARCHAR" | "VARCHAR" | "NCHAR" | <K_CHAR> | "BPCHAR" | "TEXT" | "STRING" | <K_CHARACTER> | "VARYING">
    | <#TYPE_TIME: "TIMETZ" >
    | <#TYPE_TIMESTAMP: "TIMESTAMP_NS" | "TIMESTAMP_MS" | "TIMESTAMP_S"  >

    | <#TYPE_UUID: "UUID">
}

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_DIGIT> )+ ) >
  |     < #HEX_VALUE: ["0"-"9","A"-"F", " "]  >
  |     < #HEX_DIGIT: ["0"-"9","A"-"F"]  >
}

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

// Nested block comments:  /* ... /* ... */ ... */
//
// Uses a nesting counter (commentNesting in TOKEN_MGR_DECLS) and
// lexer states DEFAULT -> IN_BLOCK_COMMENT -> BLOCK_COMMENT_END.
//
// The */ rule has NO `: STATE` suffix — this is critical because
// JavaCC's `: STATE` always overrides SwitchTo().  Without it,
// SwitchTo(BLOCK_COMMENT_END) only fires when nesting reaches 0.
//
// In BLOCK_COMMENT_END, we match one real char with ~[], then
// backup(1) to put it back.  This avoids the empty-string-at-EOF
// problem while cleanly emitting the accumulated comment image.
MORE:
{
    "/*" { commentNesting = 0; } : IN_BLOCK_COMMENT
}

<IN_BLOCK_COMMENT> MORE:
{
    "/*" { commentNesting++; }
|   "*/" {
        if (commentNesting > 0) {
            commentNesting--;
        } else {
            storedCommentImage = image.toString();
            SwitchTo(BLOCK_COMMENT_END);
        }
    }
|   < ~[] >
}

<BLOCK_COMMENT_END> SPECIAL_TOKEN:
{
    <MULTI_LINE_COMMENT: ~[] > {
        input_stream.backup(1);
        matchedToken.image = storedCommentImage;
    } : DEFAULT
}

TOKEN:
{
<S_PARAMETER: ["$"] (["0"-"9"])+ >
|
<S_DOLLAR_QUOTED_STRING: "$$">
    {
        consumeDollarQuotedString(matchedToken.image);
        matchedToken.image = input_stream.GetImage();
        matchedToken.kind = charLiteralIndex;
    }
|
<S_IDENTIFIER: (<LETTER> (<PART_LETTER>)*) | "$" | ("$" <PART_LETTER_NO_DOLLAR> (<PART_LETTER>)*)>
|   <#LETTER: <UnicodeIdentifierStart>
                | <Nd> | [ "#", "_" ] // Not SQL:2016 compliant!
                >
|   <#PART_LETTER_NO_DOLLAR: <UnicodeIdentifierStart> | <UnicodeIdentifierExtend> | [ "#", "_" , "@"  ] >
|   <#PART_LETTER: <UnicodeIdentifierStart> | <UnicodeIdentifierExtend> | [ "$" , "#", "_" , "@"  ] >
| <S_AT_IDENTIFIER: <K_AT_SIGN> (<K_AT_SIGN>)? <S_IDENTIFIER> >

// Unicode characters and categories are defined here: https://www.unicode.org/Public/UNIDATA/UnicodeData.txt
// SQL:2016 states:
// An <identifier start> is any character in the Unicode General Category classes “Lu”, “Ll”, “Lt”, “Lm”, “Lo”, or “Nl”.
// An <identifier extend> is U+00B7, “Middle Dot”, or any character in the Unicode General Category classes “Mn”, “Mc”, “Nd”, “Pc”, or “Cf”.

// unicode_identifier_start
| <#UnicodeIdentifierStart: ("\u00B7" | <Ll> | <Lm> | <Lo> | <Lt> | <Lu> | <Nl> |<CJK>) >
| <#Ll: ["a"-"z","µ","ß"-"ö","ø"-"ÿ","ā","ă","ą","ć","ĉ","ċ","č","ď","đ","ē","ĕ","ė","ę","ě","ĝ","ğ","ġ","ģ","ĥ","ħ","ĩ","ī","ĭ","į","ı","ij","ĵ","ķ"-"ĸ","ĺ","ļ","ľ","ŀ","ł","ń","ņ","ň"-"ʼn","ŋ","ō","ŏ","ő","œ","ŕ","ŗ","ř","ś","ŝ","ş","š","ţ","ť","ŧ","ũ","ū","ŭ","ů","ű","ų","ŵ","ŷ","ź","ż","ž"-"ƀ","ƃ","ƅ","ƈ","ƌ"-"ƍ","ƒ","ƕ","ƙ"-"ƛ","ƞ","ơ","ƣ","ƥ","ƨ","ƪ"-"ƫ","ƭ","ư","ƴ","ƶ","ƹ"-"ƺ","ƽ"-"ƿ","dž","lj","nj","ǎ","ǐ","ǒ","ǔ","ǖ","ǘ","ǚ","ǜ"-"ǝ","ǟ","ǡ","ǣ","ǥ","ǧ","ǩ","ǫ","ǭ","ǯ"-"ǰ","dz","ǵ","ǹ","ǻ","ǽ","ǿ","ȁ","ȃ","ȅ","ȇ","ȉ","ȋ","ȍ","ȏ","ȑ","ȓ","ȕ","ȗ","ș","ț","ȝ","ȟ","ȡ","ȣ","ȥ","ȧ","ȩ","ȫ","ȭ","ȯ","ȱ","ȳ"-"ȹ","ȼ","ȿ"-"ɀ","ɂ","ɇ","ɉ","ɋ","ɍ","ɏ"-"ʓ","ʕ"-"ʯ","ͱ","ͳ","ͷ","ͻ"-"ͽ","ΐ","ά"-"ώ","ϐ"-"ϑ","ϕ"-"ϗ","ϙ","ϛ","ϝ","ϟ","ϡ","ϣ","ϥ","ϧ","ϩ","ϫ","ϭ","ϯ"-"ϳ","ϵ","ϸ","ϻ"-"ϼ","а"-"џ","ѡ","ѣ","ѥ","ѧ","ѩ","ѫ","ѭ","ѯ","ѱ","ѳ","ѵ","ѷ","ѹ","ѻ","ѽ","ѿ","ҁ","ҋ","ҍ","ҏ","ґ","ғ","ҕ","җ","ҙ","қ","ҝ","ҟ","ҡ","ң","ҥ","ҧ","ҩ","ҫ","ҭ","ү","ұ","ҳ","ҵ","ҷ","ҹ","һ","ҽ","ҿ","ӂ","ӄ","ӆ","ӈ","ӊ","ӌ","ӎ"-"ӏ","ӑ","ӓ","ӕ","ӗ","ә","ӛ","ӝ","ӟ","ӡ","ӣ","ӥ","ӧ","ө","ӫ","ӭ","ӯ","ӱ","ӳ","ӵ","ӷ","ӹ","ӻ","ӽ","ӿ","ԁ","ԃ","ԅ","ԇ","ԉ","ԋ","ԍ","ԏ","ԑ","ԓ","ԕ","ԗ","ԙ","ԛ","ԝ","ԟ","ԡ","ԣ","ԥ","ԧ","ԩ","ԫ","ԭ","ԯ","ՠ"-"ֈ","ა"-"ჺ","ჽ"-"ჿ","ᏸ"-"ᏽ","ᲀ"-"ᲈ","ᴀ"-"ᴫ","ᵫ"-"ᵷ","ᵹ"-"ᶚ","ḁ","ḃ","ḅ","ḇ","ḉ","ḋ","ḍ","ḏ","ḑ","ḓ","ḕ","ḗ","ḙ","ḛ","ḝ","ḟ","ḡ","ḣ","ḥ","ḧ","ḩ","ḫ","ḭ","ḯ","ḱ","ḳ","ḵ","ḷ","ḹ","ḻ","ḽ","ḿ","ṁ","ṃ","ṅ","ṇ","ṉ","ṋ","ṍ","ṏ","ṑ","ṓ","ṕ","ṗ","ṙ","ṛ","ṝ","ṟ","ṡ","ṣ","ṥ","ṧ","ṩ","ṫ","ṭ","ṯ","ṱ","ṳ","ṵ","ṷ","ṹ","ṻ","ṽ","ṿ","ẁ","ẃ","ẅ","ẇ","ẉ","ẋ","ẍ","ẏ","ẑ","ẓ","ẕ"-"ẝ","ẟ","ạ","ả","ấ","ầ","ẩ","ẫ","ậ","ắ","ằ","ẳ","ẵ","ặ","ẹ","ẻ","ẽ","ế","ề","ể","ễ","ệ","ỉ","ị","ọ","ỏ","ố","ồ","ổ","ỗ","ộ","ớ","ờ","ở","ỡ","ợ","ụ","ủ","ứ","ừ","ử","ữ","ự","ỳ","ỵ","ỷ","ỹ","ỻ","ỽ","ỿ"-"ἇ","ἐ"-"ἕ","ἠ"-"ἧ","ἰ"-"ἷ","ὀ"-"ὅ","ὐ"-"ὗ","ὠ"-"ὧ","ὰ"-"ώ","ᾀ"-"ᾇ","ᾐ"-"ᾗ","ᾠ"-"ᾧ","ᾰ"-"ᾴ","ᾶ"-"ᾷ","ι","ῂ"-"ῄ","ῆ"-"ῇ","ῐ"-"ΐ","ῖ"-"ῗ","ῠ"-"ῧ","ῲ"-"ῴ","ῶ"-"ῷ","ℊ","ℎ"-"ℏ","ℓ","ℯ","ℴ","ℹ","ℼ"-"ℽ","ⅆ"-"ⅉ","ⅎ","ↄ","ⰰ"-"ⱟ","ⱡ","ⱥ"-"ⱦ","ⱨ","ⱪ","ⱬ","ⱱ","ⱳ"-"ⱴ","ⱶ"-"ⱻ","ⲁ","ⲃ","ⲅ","ⲇ","ⲉ","ⲋ","ⲍ","ⲏ","ⲑ","ⲓ","ⲕ","ⲗ","ⲙ","ⲛ","ⲝ","ⲟ","ⲡ","ⲣ","ⲥ","ⲧ","ⲩ","ⲫ","ⲭ","ⲯ","ⲱ","ⲳ","ⲵ","ⲷ","ⲹ","ⲻ","ⲽ","ⲿ","ⳁ","ⳃ","ⳅ","ⳇ","ⳉ","ⳋ","ⳍ","ⳏ","ⳑ","ⳓ","ⳕ","ⳗ","ⳙ","ⳛ","ⳝ","ⳟ","ⳡ","ⳣ"-"ⳤ","ⳬ","ⳮ","ⳳ","ⴀ"-"ⴥ","ⴧ","ⴭ","ꙁ","ꙃ","ꙅ","ꙇ","ꙉ","ꙋ","ꙍ","ꙏ","ꙑ","ꙓ","ꙕ","ꙗ","ꙙ","ꙛ","ꙝ","ꙟ","ꙡ","ꙣ","ꙥ","ꙧ","ꙩ","ꙫ","ꙭ","ꚁ","ꚃ","ꚅ","ꚇ","ꚉ","ꚋ","ꚍ","ꚏ","ꚑ","ꚓ","ꚕ","ꚗ","ꚙ","ꚛ","ꜣ","ꜥ","ꜧ","ꜩ","ꜫ","ꜭ","ꜯ"-"ꜱ","ꜳ","ꜵ","ꜷ","ꜹ","ꜻ","ꜽ","ꜿ","ꝁ","ꝃ","ꝅ","ꝇ","ꝉ","ꝋ","ꝍ","ꝏ","ꝑ","ꝓ","ꝕ","ꝗ","ꝙ","ꝛ","ꝝ","ꝟ","ꝡ","ꝣ","ꝥ","ꝧ","ꝩ","ꝫ","ꝭ","ꝯ","ꝱ"-"ꝸ","ꝺ","ꝼ","ꝿ","ꞁ","ꞃ","ꞅ","ꞇ","ꞌ","ꞎ","ꞑ","ꞓ"-"ꞕ","ꞗ","ꞙ","ꞛ","ꞝ","ꞟ","ꞡ","ꞣ","ꞥ","ꞧ","ꞩ","ꞯ","ꞵ","ꞷ","ꞹ","ꞻ","ꞽ","ꞿ","ꟁ","ꟃ","ꟈ","ꟊ","ꟑ","ꟓ","ꟕ","ꟗ","ꟙ","ꟶ","ꟺ","ꬰ"-"ꭚ","ꭠ"-"ꭨ","ꭰ"-"ꮿ","ff"-"st","ﬓ"-"ﬗ","ａ"-"ｚ"]>
| <#Lm: ["ʰ"-"ˁ","ˆ"-"ˑ","ˠ"-"ˤ","ˬ","ˮ","ʹ","ͺ","ՙ","ـ","ۥ"-"ۦ","ߴ"-"ߵ","ߺ","ࠚ","ࠤ","ࠨ","ࣉ","ॱ","ๆ","ໆ","ჼ","ៗ","ᡃ","ᪧ","ᱸ"-"ᱽ","ᴬ"-"ᵪ","ᵸ","ᶛ"-"ᶿ","ⁱ","ⁿ","ₐ"-"ₜ","ⱼ"-"ⱽ","ⵯ","ⸯ","々","〱"-"〵","〻","ゝ"-"ゞ","ー"-"ヾ","ꀕ","ꓸ"-"ꓽ","ꘌ","ꙿ","ꚜ"-"ꚝ","ꜗ"-"ꜟ","ꝰ","ꞈ","ꟲ"-"ꟴ","ꟸ"-"ꟹ","ꧏ","ꧦ","ꩰ","ꫝ","ꫳ"-"ꫴ","ꭜ"-"ꭟ","ꭩ","ｰ","ﾞ"-"ﾟ"]>
| <#Lo: ["ª","º","ƻ","ǀ"-"ǃ","ʔ","א"-"ת","ׯ"-"ײ","ؠ"-"ؿ","ف"-"ي","ٮ"-"ٯ","ٱ"-"ۓ","ە","ۮ"-"ۯ","ۺ"-"ۼ","ۿ","ܐ","ܒ"-"ܯ","ݍ"-"ޥ","ޱ","ߊ"-"ߪ","ࠀ"-"ࠕ","ࡀ"-"ࡘ","ࡠ"-"ࡪ","ࡰ"-"ࢇ","ࢉ"-"ࢎ","ࢠ"-"ࣈ","ऄ"-"ह","ऽ","ॐ","क़"-"ॡ","ॲ"-"ঀ","অ"-"ঌ","এ"-"ঐ","ও"-"ন","প"-"র","ল","শ"-"হ","ঽ","ৎ","ড়"-"ঢ়","য়"-"ৡ","ৰ"-"ৱ","ৼ","ਅ"-"ਊ","ਏ"-"ਐ","ਓ"-"ਨ","ਪ"-"ਰ","ਲ"-"ਲ਼","ਵ"-"ਸ਼","ਸ"-"ਹ","ਖ਼"-"ੜ","ਫ਼","ੲ"-"ੴ","અ"-"ઍ","એ"-"ઑ","ઓ"-"ન","પ"-"ર","લ"-"ળ","વ"-"હ","ઽ","ૐ","ૠ"-"ૡ","ૹ","ଅ"-"ଌ","ଏ"-"ଐ","ଓ"-"ନ","ପ"-"ର","ଲ"-"ଳ","ଵ"-"ହ","ଽ","ଡ଼"-"ଢ଼","ୟ"-"ୡ","ୱ","ஃ","அ"-"ஊ","எ"-"ஐ","ஒ"-"க","ங"-"ச","ஜ","ஞ"-"ட","ண"-"த","ந"-"ப","ம"-"ஹ","ௐ","అ"-"ఌ","ఎ"-"ఐ","ఒ"-"న","ప"-"హ","ఽ","ౘ"-"ౚ","ౝ","ౠ"-"ౡ","ಀ","ಅ"-"ಌ","ಎ"-"ಐ","ಒ"-"ನ","ಪ"-"ಳ","ವ"-"ಹ","ಽ","ೝ"-"ೞ","ೠ"-"ೡ","ೱ"-"ೲ","ഄ"-"ഌ","എ"-"ഐ","ഒ"-"ഺ","ഽ","ൎ","ൔ"-"ൖ","ൟ"-"ൡ","ൺ"-"ൿ","අ"-"ඖ","ක"-"න","ඳ"-"ර","ල","ව"-"ෆ","ก"-"ะ","า"-"ำ","เ"-"ๅ","ກ"-"ຂ","ຄ","ຆ"-"ຊ","ຌ"-"ຣ","ລ","ວ"-"ະ","າ"-"ຳ","ຽ","ເ"-"ໄ","ໜ"-"ໟ","ༀ","ཀ"-"ཇ","ཉ"-"ཬ","ྈ"-"ྌ","က"-"ဪ","ဿ","ၐ"-"ၕ","ၚ"-"ၝ","ၡ","ၥ"-"ၦ","ၮ"-"ၰ","ၵ"-"ႁ","ႎ","ᄀ"-"ቈ","ቊ"-"ቍ","ቐ"-"ቖ","ቘ","ቚ"-"ቝ","በ"-"ኈ","ኊ"-"ኍ","ነ"-"ኰ","ኲ"-"ኵ","ኸ"-"ኾ","ዀ","ዂ"-"ዅ","ወ"-"ዖ","ዘ"-"ጐ","ጒ"-"ጕ","ጘ"-"ፚ","ᎀ"-"ᎏ","ᐁ"-"ᙬ","ᙯ"-"ᙿ","ᚁ"-"ᚚ","ᚠ"-"ᛪ","ᛱ"-"ᛸ","ᜀ"-"ᜑ","ᜟ"-"ᜱ","ᝀ"-"ᝑ","ᝠ"-"ᝬ","ᝮ"-"ᝰ","ក"-"ឳ","ៜ","ᠠ"-"ᡂ","ᡄ"-"ᡸ","ᢀ"-"ᢄ","ᢇ"-"ᢨ","ᢪ","ᢰ"-"ᣵ","ᤀ"-"ᤞ","ᥐ"-"ᥭ","ᥰ"-"ᥴ","ᦀ"-"ᦫ","ᦰ"-"ᧉ","ᨀ"-"ᨖ","ᨠ"-"ᩔ","ᬅ"-"ᬳ","ᭅ"-"ᭌ","ᮃ"-"ᮠ","ᮮ"-"ᮯ","ᮺ"-"ᯥ","ᰀ"-"ᰣ","ᱍ"-"ᱏ","ᱚ"-"ᱷ","ᳩ"-"ᳬ","ᳮ"-"ᳳ","ᳵ"-"ᳶ","ᳺ","ℵ"-"ℸ","ⴰ"-"ⵧ","ⶀ"-"ⶖ","ⶠ"-"ⶦ","ⶨ"-"ⶮ","ⶰ"-"ⶶ","ⶸ"-"ⶾ","ⷀ"-"ⷆ","ⷈ"-"ⷎ","ⷐ"-"ⷖ","ⷘ"-"ⷞ","〆","〼","ぁ"-"ゖ","ゟ","ァ"-"ヺ","ヿ","ㄅ"-"ㄯ","ㄱ"-"ㆎ","ㆠ"-"ㆿ","ㇰ"-"ㇿ","䶿","鿿"-"ꀔ","ꀖ"-"ꒌ","ꓐ"-"ꓷ","ꔀ"-"ꘋ","ꘐ"-"ꘟ","ꘪ"-"ꘫ","ꙮ","ꚠ"-"ꛥ","ꞏ","ꟷ","ꟻ"-"ꠁ","ꠃ"-"ꠅ","ꠇ"-"ꠊ","ꠌ"-"ꠢ","ꡀ"-"ꡳ","ꢂ"-"ꢳ","ꣲ"-"ꣷ","ꣻ","ꣽ"-"ꣾ","ꤊ"-"ꤥ","ꤰ"-"ꥆ","ꥠ"-"ꥼ","ꦄ"-"ꦲ","ꧠ"-"ꧤ","ꧧ"-"ꧯ","ꧺ"-"ꧾ","ꨀ"-"ꨨ","ꩀ"-"ꩂ","ꩄ"-"ꩋ","ꩠ"-"ꩯ","ꩱ"-"ꩶ","ꩺ","ꩾ"-"ꪯ","ꪱ","ꪵ"-"ꪶ","ꪹ"-"ꪽ","ꫀ","ꫂ","ꫛ"-"ꫜ","ꫠ"-"ꫪ","ꫲ","ꬁ"-"ꬆ","ꬉ"-"ꬎ","ꬑ"-"ꬖ","ꬠ"-"ꬦ","ꬨ"-"ꬮ","ꯀ"-"ꯢ","힣","ힰ"-"ퟆ","ퟋ"-"ퟻ","豈"-"舘","並"-"龎","יִ","ײַ"-"ﬨ","שׁ"-"זּ","טּ"-"לּ","מּ","נּ"-"סּ","ףּ"-"פּ","צּ"-"ﮱ","ﯓ"-"ﴽ","ﵐ"-"ﶏ","ﶒ"-"ﷇ","ﷰ"-"ﷻ","ﹰ"-"ﹴ","ﹶ"-"ﻼ","ｦ"-"ｯ","ｱ"-"ﾝ","ﾠ"-"ﾾ","ￂ"-"ￇ","ￊ"-"ￏ","ￒ"-"ￗ","ￚ"-"ￜ"]>
| <#Lt: ["Dž","Lj","Nj","Dz","ᾈ"-"ᾏ","ᾘ"-"ᾟ","ᾨ"-"ᾯ","ᾼ","ῌ","ῼ"]>
| <#Lu: ["A"-"Z","À"-"Ö","Ø"-"Þ","Ā","Ă","Ą","Ć","Ĉ","Ċ","Č","Ď","Đ","Ē","Ĕ","Ė","Ę","Ě","Ĝ","Ğ","Ġ","Ģ","Ĥ","Ħ","Ĩ","Ī","Ĭ","Į","İ","IJ","Ĵ","Ķ","Ĺ","Ļ","Ľ","Ŀ","Ł","Ń","Ņ","Ň","Ŋ","Ō","Ŏ","Ő","Œ","Ŕ","Ŗ","Ř","Ś","Ŝ","Ş","Š","Ţ","Ť","Ŧ","Ũ","Ū","Ŭ","Ů","Ű","Ų","Ŵ","Ŷ","Ÿ"-"Ź","Ż","Ž","Ɓ"-"Ƃ","Ƅ","Ɔ"-"Ƈ","Ɖ"-"Ƌ","Ǝ"-"Ƒ","Ɠ"-"Ɣ","Ɩ"-"Ƙ","Ɯ"-"Ɲ","Ɵ"-"Ơ","Ƣ","Ƥ","Ʀ"-"Ƨ","Ʃ","Ƭ","Ʈ"-"Ư","Ʊ"-"Ƴ","Ƶ","Ʒ"-"Ƹ","Ƽ","DŽ","LJ","NJ","Ǎ","Ǐ","Ǒ","Ǔ","Ǖ","Ǘ","Ǚ","Ǜ","Ǟ","Ǡ","Ǣ","Ǥ","Ǧ","Ǩ","Ǫ","Ǭ","Ǯ","DZ","Ǵ","Ƕ"-"Ǹ","Ǻ","Ǽ","Ǿ","Ȁ","Ȃ","Ȅ","Ȇ","Ȉ","Ȋ","Ȍ","Ȏ","Ȑ","Ȓ","Ȕ","Ȗ","Ș","Ț","Ȝ","Ȟ","Ƞ","Ȣ","Ȥ","Ȧ","Ȩ","Ȫ","Ȭ","Ȯ","Ȱ","Ȳ","Ⱥ"-"Ȼ","Ƚ"-"Ⱦ","Ɂ","Ƀ"-"Ɇ","Ɉ","Ɋ","Ɍ","Ɏ","Ͱ","Ͳ","Ͷ","Ϳ","Ά","Έ"-"Ί","Ό","Ύ"-"Ώ","Α"-"Ρ","Σ"-"Ϋ","Ϗ","ϒ"-"ϔ","Ϙ","Ϛ","Ϝ","Ϟ","Ϡ","Ϣ","Ϥ","Ϧ","Ϩ","Ϫ","Ϭ","Ϯ","ϴ","Ϸ","Ϲ"-"Ϻ","Ͻ"-"Я","Ѡ","Ѣ","Ѥ","Ѧ","Ѩ","Ѫ","Ѭ","Ѯ","Ѱ","Ѳ","Ѵ","Ѷ","Ѹ","Ѻ","Ѽ","Ѿ","Ҁ","Ҋ","Ҍ","Ҏ","Ґ","Ғ","Ҕ","Җ","Ҙ","Қ","Ҝ","Ҟ","Ҡ","Ң","Ҥ","Ҧ","Ҩ","Ҫ","Ҭ","Ү","Ұ","Ҳ","Ҵ","Ҷ","Ҹ","Һ","Ҽ","Ҿ","Ӏ"-"Ӂ","Ӄ","Ӆ","Ӈ","Ӊ","Ӌ","Ӎ","Ӑ","Ӓ","Ӕ","Ӗ","Ә","Ӛ","Ӝ","Ӟ","Ӡ","Ӣ","Ӥ","Ӧ","Ө","Ӫ","Ӭ","Ӯ","Ӱ","Ӳ","Ӵ","Ӷ","Ӹ","Ӻ","Ӽ","Ӿ","Ԁ","Ԃ","Ԅ","Ԇ","Ԉ","Ԋ","Ԍ","Ԏ","Ԑ","Ԓ","Ԕ","Ԗ","Ԙ","Ԛ","Ԝ","Ԟ","Ԡ","Ԣ","Ԥ","Ԧ","Ԩ","Ԫ","Ԭ","Ԯ","Ա"-"Ֆ","Ⴀ"-"Ⴥ","Ⴧ","Ⴭ","Ꭰ"-"Ᏽ","Ა"-"Ჺ","Ჽ"-"Ჿ","Ḁ","Ḃ","Ḅ","Ḇ","Ḉ","Ḋ","Ḍ","Ḏ","Ḑ","Ḓ","Ḕ","Ḗ","Ḙ","Ḛ","Ḝ","Ḟ","Ḡ","Ḣ","Ḥ","Ḧ","Ḩ","Ḫ","Ḭ","Ḯ","Ḱ","Ḳ","Ḵ","Ḷ","Ḹ","Ḻ","Ḽ","Ḿ","Ṁ","Ṃ","Ṅ","Ṇ","Ṉ","Ṋ","Ṍ","Ṏ","Ṑ","Ṓ","Ṕ","Ṗ","Ṙ","Ṛ","Ṝ","Ṟ","Ṡ","Ṣ","Ṥ","Ṧ","Ṩ","Ṫ","Ṭ","Ṯ","Ṱ","Ṳ","Ṵ","Ṷ","Ṹ","Ṻ","Ṽ","Ṿ","Ẁ","Ẃ","Ẅ","Ẇ","Ẉ","Ẋ","Ẍ","Ẏ","Ẑ","Ẓ","Ẕ","ẞ","Ạ","Ả","Ấ","Ầ","Ẩ","Ẫ","Ậ","Ắ","Ằ","Ẳ","Ẵ","Ặ","Ẹ","Ẻ","Ẽ","Ế","Ề","Ể","Ễ","Ệ","Ỉ","Ị","Ọ","Ỏ","Ố","Ồ","Ổ","Ỗ","Ộ","Ớ","Ờ","Ở","Ỡ","Ợ","Ụ","Ủ","Ứ","Ừ","Ử","Ữ","Ự","Ỳ","Ỵ","Ỷ","Ỹ","Ỻ","Ỽ","Ỿ","Ἀ"-"Ἇ","Ἐ"-"Ἕ","Ἠ"-"Ἧ","Ἰ"-"Ἷ","Ὀ"-"Ὅ","Ὑ","Ὓ","Ὕ","Ὗ","Ὠ"-"Ὧ","Ᾰ"-"Ά","Ὲ"-"Ή","Ῐ"-"Ί","Ῠ"-"Ῥ","Ὸ"-"Ώ","ℂ","ℇ","ℋ"-"ℍ","ℐ"-"ℒ","ℕ","ℙ"-"ℝ","ℤ","Ω","ℨ","K"-"ℭ","ℰ"-"ℳ","ℾ"-"ℿ","ⅅ","Ↄ","Ⰰ"-"Ⱟ","Ⱡ","Ɫ"-"Ɽ","Ⱨ","Ⱪ","Ⱬ","Ɑ"-"Ɒ","Ⱳ","Ⱶ","Ȿ"-"Ⲁ","Ⲃ","Ⲅ","Ⲇ","Ⲉ","Ⲋ","Ⲍ","Ⲏ","Ⲑ","Ⲓ","Ⲕ","Ⲗ","Ⲙ","Ⲛ","Ⲝ","Ⲟ","Ⲡ","Ⲣ","Ⲥ","Ⲧ","Ⲩ","Ⲫ","Ⲭ","Ⲯ","Ⲱ","Ⲳ","Ⲵ","Ⲷ","Ⲹ","Ⲻ","Ⲽ","Ⲿ","Ⳁ","Ⳃ","Ⳅ","Ⳇ","Ⳉ","Ⳋ","Ⳍ","Ⳏ","Ⳑ","Ⳓ","Ⳕ","Ⳗ","Ⳙ","Ⳛ","Ⳝ","Ⳟ","Ⳡ","Ⳣ","Ⳬ","Ⳮ","Ⳳ","Ꙁ","Ꙃ","Ꙅ","Ꙇ","Ꙉ","Ꙋ","Ꙍ","Ꙏ","Ꙑ","Ꙓ","Ꙕ","Ꙗ","Ꙙ","Ꙛ","Ꙝ","Ꙟ","Ꙡ","Ꙣ","Ꙥ","Ꙧ","Ꙩ","Ꙫ","Ꙭ","Ꚁ","Ꚃ","Ꚅ","Ꚇ","Ꚉ","Ꚋ","Ꚍ","Ꚏ","Ꚑ","Ꚓ","Ꚕ","Ꚗ","Ꚙ","Ꚛ","Ꜣ","Ꜥ","Ꜧ","Ꜩ","Ꜫ","Ꜭ","Ꜯ","Ꜳ","Ꜵ","Ꜷ","Ꜹ","Ꜻ","Ꜽ","Ꜿ","Ꝁ","Ꝃ","Ꝅ","Ꝇ","Ꝉ","Ꝋ","Ꝍ","Ꝏ","Ꝑ","Ꝓ","Ꝕ","Ꝗ","Ꝙ","Ꝛ","Ꝝ","Ꝟ","Ꝡ","Ꝣ","Ꝥ","Ꝧ","Ꝩ","Ꝫ","Ꝭ","Ꝯ","Ꝺ","Ꝼ","Ᵹ"-"Ꝿ","Ꞁ","Ꞃ","Ꞅ","Ꞇ","Ꞌ","Ɥ","Ꞑ","Ꞓ","Ꞗ","Ꞙ","Ꞛ","Ꞝ","Ꞟ","Ꞡ","Ꞣ","Ꞥ","Ꞧ","Ꞩ","Ɦ"-"Ɪ","Ʞ"-"Ꞵ","Ꞷ","Ꞹ","Ꞻ","Ꞽ","Ꞿ","Ꟁ","Ꟃ","Ꞔ"-"Ꟈ","Ꟊ","Ꟑ","Ꟗ","Ꟙ","Ꟶ","Ａ"-"Ｚ"]>
| <#Nl: ["ᛮ"-"ᛰ","Ⅰ"-"ↂ","ↅ"-"ↈ","〇","〡"-"〩","〸"-"〺","ꛦ"-"ꛯ"]>

// unicode_identifier_extend
| <#UnicodeIdentifierExtend: (<Mn>|<Mc>|<Nd>|<Pc>|<Cf>|<CJK>)>
| <#Cf: ["­","؀"-"؅","؜","۝","܏","࢐"-"࢑","࣢","᠎","​"-"‏","‪"-"‮","⁠"-"⁤","⁦"-"","",""-""]>
| <#Mc: ["ः","ऻ","ा"-"ी","ॉ"-"ौ","ॎ"-"ॏ","ং"-"ঃ","া"-"ী","ে"-"ৈ","ো"-"ৌ","ৗ","ਃ","ਾ"-"ੀ","ઃ","ા"-"ી","ૉ","ો"-"ૌ","ଂ"-"ଃ","ା","ୀ","େ"-"ୈ","ୋ"-"ୌ","ୗ","ா"-"ி","ு"-"ூ","ெ"-"ை","ொ"-"ௌ","ௗ","ఁ"-"ః","ు"-"ౄ","ಂ"-"ಃ","ಾ","ೀ"-"ೄ","ೇ"-"ೈ","ೊ"-"ೋ","ೕ"-"ೖ","ೳ","ം"-"ഃ","ാ"-"ീ","െ"-"ൈ","ൊ"-"ൌ","ൗ","ං"-"ඃ","ා"-"ෑ","ෘ"-"ෟ","ෲ"-"ෳ","༾"-"༿","ཿ","ါ"-"ာ","ေ","း","ျ"-"ြ","ၖ"-"ၗ","ၢ"-"ၤ","ၧ"-"ၭ","ႃ"-"ႄ","ႇ"-"ႌ","ႏ","ႚ"-"ႜ","᜕","᜴","ា","ើ"-"ៅ","ះ"-"ៈ","ᤣ"-"ᤦ","ᤩ"-"ᤫ","ᤰ"-"ᤱ","ᤳ"-"ᤸ","ᨙ"-"ᨚ","ᩕ","ᩗ","ᩡ","ᩣ"-"ᩤ","ᩭ"-"ᩲ","ᬄ","ᬵ","ᬻ","ᬽ"-"ᭁ","ᭃ"-"᭄","ᮂ","ᮡ","ᮦ"-"ᮧ","᮪","ᯧ","ᯪ"-"ᯬ","ᯮ","᯲"-"᯳","ᰤ"-"ᰫ","ᰴ"-"ᰵ","᳡","᳷","〮"-"〯","ꠣ"-"ꠤ","ꠧ","ꢀ"-"ꢁ","ꢴ"-"ꣃ","ꥒ"-"꥓","ꦃ","ꦴ"-"ꦵ","ꦺ"-"ꦻ","ꦾ"-"꧀","ꨯ"-"ꨰ","ꨳ"-"ꨴ","ꩍ","ꩻ","ꩽ","ꫫ","ꫮ"-"ꫯ","ꫵ","ꯣ"-"ꯤ","ꯦ"-"ꯧ","ꯩ"-"ꯪ","꯬"]>
| <#Mn: ["̀"-"ͯ","҃"-"҇","֑"-"ֽ","ֿ","ׁ"-"ׂ","ׄ"-"ׅ","ׇ","ؐ"-"ؚ","ً"-"ٟ","ٰ","ۖ"-"ۜ","۟"-"ۤ","ۧ"-"ۨ","۪"-"ۭ","ܑ","ܰ"-"݊","ަ"-"ް","߫"-"߳","߽","ࠖ"-"࠙","ࠛ"-"ࠣ","ࠥ"-"ࠧ","ࠩ"-"࠭","࡙"-"࡛","࢘"-"࢟","࣊"-"࣡","ࣣ"-"ं","ऺ","़","ु"-"ै","्","॑"-"ॗ","ॢ"-"ॣ","ঁ","়","ু"-"ৄ","্","ৢ"-"ৣ","৾","ਁ"-"ਂ","਼","ੁ"-"ੂ","ੇ"-"ੈ","ੋ"-"੍","ੑ","ੰ"-"ੱ","ੵ","ઁ"-"ં","઼","ુ"-"ૅ","ે"-"ૈ","્","ૢ"-"ૣ","ૺ"-"૿","ଁ","଼","ି","ୁ"-"ୄ","୍","୕"-"ୖ","ୢ"-"ୣ","ஂ","ீ","்","ఀ","ఄ","఼","ా"-"ీ","ె"-"ై","ొ"-"్","ౕ"-"ౖ","ౢ"-"ౣ","ಁ","಼","ಿ","ೆ","ೌ"-"್","ೢ"-"ೣ","ഀ"-"ഁ","഻"-"഼","ു"-"ൄ","്","ൢ"-"ൣ","ඁ","්","ි"-"ු","ූ","ั","ิ"-"ฺ","็"-"๎","ັ","ິ"-"ຼ","່"-"໎","༘"-"༙","༵","༷","༹","ཱ"-"ཾ","ྀ"-"྄","྆"-"྇","ྍ"-"ྗ","ྙ"-"ྼ","࿆","ိ"-"ူ","ဲ"-"့","္"-"်","ွ"-"ှ","ၘ"-"ၙ","ၞ"-"ၠ","ၱ"-"ၴ","ႂ","ႅ"-"ႆ","ႍ","ႝ","፝"-"፟","ᜒ"-"᜔","ᜲ"-"ᜳ","ᝒ"-"ᝓ","ᝲ"-"ᝳ","឴"-"឵","ិ"-"ួ","ំ","៉"-"៓","៝","᠋"-"᠍","᠏","ᢅ"-"ᢆ","ᢩ","ᤠ"-"ᤢ","ᤧ"-"ᤨ","ᤲ","᤹"-"᤻","ᨗ"-"ᨘ","ᨛ","ᩖ","ᩘ"-"ᩞ","᩠","ᩢ","ᩥ"-"ᩬ","ᩳ"-"᩼","᩿","᪰"-"᪽","ᪿ"-"ᫎ","ᬀ"-"ᬃ","᬴","ᬶ"-"ᬺ","ᬼ","ᭂ","᭫"-"᭳","ᮀ"-"ᮁ","ᮢ"-"ᮥ","ᮨ"-"ᮩ","᮫"-"ᮭ","᯦","ᯨ"-"ᯩ","ᯭ","ᯯ"-"ᯱ","ᰬ"-"ᰳ","ᰶ"-"᰷","᳐"-"᳒","᳔"-"᳠","᳢"-"᳨","᳭","᳴","᳸"-"᳹","᷀"-"᷿","⃐"-"⃜","⃡","⃥"-"⃰","⳯"-"⳱","⵿","ⷠ"-"ⷿ","〪"-"〭","゙"-"゚","꙯","ꙴ"-"꙽","ꚞ"-"ꚟ","꛰"-"꛱","ꠂ","꠆","ꠋ","ꠥ"-"ꠦ","꠬","꣄"-"ꣅ","꣠"-"꣱","ꣿ","ꤦ"-"꤭","ꥇ"-"ꥑ","ꦀ"-"ꦂ","꦳","ꦶ"-"ꦹ","ꦼ"-"ꦽ","ꧥ","ꨩ"-"ꨮ","ꨱ"-"ꨲ","ꨵ"-"ꨶ","ꩃ","ꩌ","ꩼ","ꪰ","ꪲ"-"ꪴ","ꪷ"-"ꪸ","ꪾ"-"꪿","꫁","ꫬ"-"ꫭ","꫶","ꯥ","ꯨ","꯭","ﬞ","︀"-"️","︠"-"︯"]>
| <#Nd: ["0"-"9","٠"-"٩","۰"-"۹","߀"-"߉","०"-"९","০"-"৯","੦"-"੯","૦"-"૯","୦"-"୯","௦"-"௯","౦"-"౯","೦"-"೯","൦"-"൯","෦"-"෯","๐"-"๙","໐"-"໙","༠"-"༩","၀"-"၉","႐"-"႙","០"-"៩","᠐"-"᠙","᥆"-"᥏","᧐"-"᧙","᪀"-"᪉","᪐"-"᪙","᭐"-"᭙","᮰"-"᮹","᱀"-"᱉","᱐"-"᱙","꘠"-"꘩","꣐"-"꣙","꤀"-"꤉","꧐"-"꧙","꧰"-"꧹","꩐"-"꩙","꯰"-"꯹","０"-"９"]>
| <#Pc: ["‿"-"⁀","⁔","︳"-"︴","﹍"-"﹏","＿"]>

// CJK Unified Ideographs block according to https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
| <#CJK: ["\uAC00"-"\uD7A3", "\u4E00"-"\u9FFF"]>

| < #SPECIAL_ESC: "\\'" > /* Allowing this will break LIKE ... ESCAPE ...  */
| < #ESC: "\\" ["n","t","b","r","f","\\","\""] >
| < S_CHAR_LITERAL: (
                        (["U","E","N","R","B"]|"RB"|"_utf8")?
                        (
                            ("'" ( <ESC> | <SPECIAL_ESC> | ~["'", "\\"] )* "'") | ("'" ("''" | ~["'"])* "'")
                            // Alternative Oracle Escape Modes
                            | ("q'{" (~[])* "}'")
                            | ("q'(" (~[])* ")'")
                            | ("q'[" (~[])* "]'")
                            | ("q''" (~[])* "''")
                            // | ("q'\\" (~[])* "\\'") <--- Does not work
                        )
                     ) >
    {
        // <S_CHAR_LITERAL> contains the <SPECIAL_ESC> token and always the longest match is returned
        // So when Backslash is explicitly not allowed as an Escape Character and a <S_CHAR_LITERAL> is found
        // which contains the <SPECIAL_ESC>, then we will need to
        // 1) break the <S_CHAR_LITERAL> at <SPECIAL_ESC> close it with a "'"
        // 2) continue tokenizing after that <SPECIAL_ESC> with a new <S_CHAR_LITERAL> or any other Token
        boolean allowEscape = configuration.getAsBoolean(Feature.allowBackslashEscapeCharacter);
                String img = matchedToken.image;
                int pos;
                if (!allowEscape) {
                    pos = indexOfSequence(img, "\\'");
                    if (pos > 0) {
                        matchedToken.image = "'" + image.substring( 0, image.indexOf("\\'") + 1 ) + "'";
                        // `charLiteralIndex` defined in TokenManagerDeclaration above
                        matchedToken.kind = charLiteralIndex;
                        input_stream.backup(image.length() + 1 - matchedToken.image.length());
                    }
                } else {
                    pos = lastIndexOfSequence(img, "\\''");
                    if (pos > 0) {
                        matchedToken.image = "'" + image.substring( 0, image.lastIndexOf("\\'") + 3);
                        // `charLiteralIndex` defined in TokenManagerDeclaration above
                        matchedToken.kind = charLiteralIndex;
                        input_stream.backup(image.length() + 1 - matchedToken.image.length() );
                    }
                }
    }
| < S_QUOTED_IDENTIFIER: "\"" ( "\"\"" | ~["\n","\r","\""])* "\"" | ("`" (~["\n","\r","`"])+ "`") | ( "[" (~["\n","\r","]"])* "]" ) >
    {
        if ( !configuration.getAsBoolean(Feature.allowSquareBracketQuotation)
            && matchedToken.image.charAt(0) == '[' ) {

            matchedToken.image = "[";
            // `squaredBracketOpenIndex` defined in TokenManagerDeclaration above
            matchedToken.kind = squaredBracketOpenIndex;
            input_stream.backup(image.length() - 1);
        }
    }
}

/**
 * Parses identifiers including standard SQL identifiers, quoted identifiers, and specific keywords.
 *
 * This is used in cases where certain SQL keywords (like NAME, NEXT, VALUE, etc.) can appear
 * as identifiers (e.g., table names, column names) depending on the SQL dialect or context.
 *
 * Supported tokens:
 *  - <S_IDENTIFIER>: Standard unquoted SQL identifier
 *  - <S_QUOTED_IDENTIFIER>: Quoted identifier (e.g., `identifier` or "identifier")
 *  - <K_NAME>, <K_NEXT>, <K_VALUE>, <K_PUBLIC>, <K_STRING>, <K_DATA>, <K_TYPE>: Specific keywords treated as identifiers
 *
 * @return Token representing the identifier or keyword used as identifier
 */
Token KeywordOrIdentifier():
{
    Token tk;
}
{
    (
        tk = <S_IDENTIFIER>
      | tk = <S_QUOTED_IDENTIFIER>
      | tk = <K_NAME>
      | tk = <K_NEXT>
      | tk = <K_VALUE>
      | tk = <K_PUBLIC>
      | tk = <K_STRING>
      | tk = <K_DATA>
      | tk = <K_TYPE>
    )
    { return tk; }
}

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

                 [
                     LOOKAHEAD(2) <ST_SEMICOLON>
                     { if (stm2!=null)
                           ifElseStatement.setUsingSemicolonForElseStatement(true);
                        else if (ifElseStatement!=null)
                           ifElseStatement.setUsingSemicolonForIfStatement(true);
                     }
                 ]
            )
            |
            (
                (stm = SingleStatement()
                    | stm = Block())

                ( <ST_SEMICOLON> | <EOF> )
            )
            |
            LOOKAHEAD( { stm==null && getAsBoolean(Feature.allowUnsupportedStatements) } ) stm = UnsupportedStatement()
         } catch (ParseException ex) {
            if ( getAsBoolean(Feature.allowUnsupportedStatements) ) {
                stm = new UnsupportedStatement( stm.toString(), error_skipto(ST_SEMICOLON) );
            } else if ( errorRecovery ) {
                parseErrors.add(ex);
                error_skipto(ST_SEMICOLON);
                stm = null;
            } else {
                throw ex;
            }
         }

    )

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

Statement SingleStatement() :
{
    Statement stm = null;
    List<WithItem<?>> with = null;
}
{
        (
           LOOKAHEAD(3) (
                [ LOOKAHEAD(2) with=WithList() ]
                (
                    stm = SelectWithWithItems( with )
                    |
                    stm = InsertWithWithItems( with )
                    |
                    stm = UpdateWithWithItems( with )
                    |
                    stm = DeleteWithWithItems( with )
                    |
                    stm = Merge( with )
                )
            )
            |
            stm = Select()
            |
            stm = TableStatement()
            |
            LOOKAHEAD(3) stm = Upsert()
            |
            LOOKAHEAD(2) stm = Alter()
            |
            // @todo: merge this into the ALTER TABLE statement
            stm = RenameTableStatement()
            |
            stm = Create()
            |
            stm = Drop()
            |
            stm = Analyze()
            |
            stm = Truncate()
            |
            stm = Execute()
            |
            stm = Set()
            |
            stm = Reset()
            |
            stm = Show()
            |
            stm = RefreshMaterializedView()
            |
            stm = Use()
            |
            stm = SavepointStatement()
            |
            stm = RollbackStatement()
            |
            stm = Commit()
            |
            stm = Comment()
            |
            stm = Describe()
            |
            stm = Explain()
            |
            stm = Declare()
            |
            stm = Grant()
            |
            stm = PurgeStatement()
            |
            stm = SessionStatement()
            |
            stm = LockStatement()
            |
            LOOKAHEAD({ Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) ( stm = Import() | stm = Export() )
        )
        { return stm; }
}

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

        (
             (
                (
                    stm = SingleStatement()
                    | stm = Block()
                )
                <ST_SEMICOLON>
                { list.add(stm); }
            )
       )*

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

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

Statements Statements() #Statements: {
    Statements stmts = new Statements();
    IfElseStatement ifElseStatement = null;
    Statement stm = null;
    Statement stm2 = null;
    Expression condition;
}
{
    (
        (
             ( <ST_SEMICOLON> )*

             // todo: allow also first statement to be an `UnsupportedStatement`
             try {
                (
                     <K_IF> condition=Condition()
                     ( stm = SingleStatement() | stm = Block() ) {  ifElseStatement = new IfElseStatement(condition, stm); }
                     [ LOOKAHEAD(2)
                         [ <ST_SEMICOLON> { ifElseStatement.setUsingSemicolonForIfStatement(true); } ]
                         <K_ELSE> ( stm2 = SingleStatement() |  stm2 =  Block() ) {  ifElseStatement.setElseStatement(stm2);  }
                     ]

                     { stmts.add( ifElseStatement ); }

                     [
                         LOOKAHEAD(2) <ST_SEMICOLON>
                         { if (stm2!=null)
                               ifElseStatement.setUsingSemicolonForElseStatement(true);
                            else if (ifElseStatement!=null)
                               ifElseStatement.setUsingSemicolonForIfStatement(true);
                         }
                     ]
                )
                |
                (
                    (stm = SingleStatement()
                        | stm = Block())

                    ( <ST_SEMICOLON> | <EOF> )
                )
                {
                    stmts.add(stm); stm=null;
                }

             } catch (ParseException ex) {
                if ( getAsBoolean(Feature.allowUnsupportedStatements) ) {
                    UnsupportedStatement unsupportedStatement = new UnsupportedStatement( stm!=null ? stm.toString() : "", error_skipto(ST_SEMICOLON) );
                    if (!unsupportedStatement.isEmpty()) {
                        stmts.add( unsupportedStatement );
                    }
                } else if ( errorRecovery ) {
                    parseErrors.add(ex);
                    error_skipto(ST_SEMICOLON);
                    stmts.add( null );
                } else {
                    throw ex;
                }
             }

        )

        (  LOOKAHEAD(2)
            ( <ST_SEMICOLON> )*
            try {
                (
                    <K_IF> condition=Condition()
                    ( stm = SingleStatement() | stm = Block() ) {  ifElseStatement = new IfElseStatement(condition, stm); }
                    [ LOOKAHEAD(2)
                        [ <ST_SEMICOLON> { ifElseStatement.setUsingSemicolonForIfStatement(true); } ]
                        <K_ELSE> ( stm2 = SingleStatement() | stm2 = Block() ) {  ifElseStatement.setElseStatement(stm2);  }
                    ]

                    { stmts.add( ifElseStatement ); }
               )
               |
                (
                    stm = SingleStatement()
                    | stm = Block()
                ) { stmts.add(stm); stm=null; }
            } catch (ParseException ex) {
               if ( getAsBoolean(Feature.allowUnsupportedStatements) ) {
                   UnsupportedStatement unsupportedStatement = new UnsupportedStatement( stm!=null ? stm.toString() : "" , error_skipto(ST_SEMICOLON) );
                   if (!unsupportedStatement.isEmpty()) {
                       stmts.add( unsupportedStatement );
                   }
               } else if ( errorRecovery ) {
                   parseErrors.add(ex);
                   error_skipto(ST_SEMICOLON);
                   stmts.add( null );
               } else {
                   throw ex;
               }
            }

            ( LOOKAHEAD(2) <ST_SEMICOLON> { if (stm2!=null)
                             ifElseStatement.setUsingSemicolonForElseStatement(true);
                          else if (ifElseStatement!=null)
                             ifElseStatement.setUsingSemicolonForIfStatement(true);
             } )*

        )*

        [
            LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } )
            stm = UnsupportedStatement()
            {
                if (!( (UnsupportedStatement) stm).isEmpty()) {
                    stmts.add( stm );
                }
            }
        ]

    )*

    <EOF>
    {
        return stmts;
    }
}

JAVACODE
List<String> error_skipto(int kind) {
  ArrayList<String> tokenImages = new ArrayList<String>();
  ParseException e = generateParseException("test");
  Token t;
  do {
    t = getNextToken();
    if (t.kind != kind && t.kind != EOF) {
        tokenImages.add(t.image);
    }
  } while (t.kind != kind && t.kind != EOF);
  return tokenImages;
}

LockStatement LockStatement(): {
  	Table table;
  	boolean noWait = false;
  	LockMode lockMode;
    Token waitSecondsToken = null;
    Long waitSeconds = null;
} {
  	<K_LOCK> <K_TABLE> table = Table() <K_IN>
  	(
  	  LOOKAHEAD(2) ( <K_ROW> <K_SHARE> { lockMode = LockMode.RowShare; } ) |
  	  ( <K_ROW> <K_EXCLUSIVE> { lockMode = LockMode.RowExclusive; } ) |
	  LOOKAHEAD(2) ( <K_SHARE> <K_ROW> <K_EXCLUSIVE> { lockMode = LockMode.ShareRowExclusive; } ) |
  	  LOOKAHEAD(2) ( <K_SHARE> <K_UPDATE> { lockMode = LockMode.ShareUpdate; }  ) |
  	  ( <K_SHARE> { lockMode = LockMode.Share; } ) |
  	  ( <K_EXCLUSIVE > { lockMode = LockMode.Exclusive; } )
  	)
  	<K_MODE>
    [ <K_NOWAIT> { noWait = true; } | <K_WAIT> waitSecondsToken = <S_LONG> { waitSeconds = Long.valueOf(waitSecondsToken.image); } ]

  {
    return new LockStatement(table, lockMode, noWait, waitSeconds);
  }
}

LikeClause LikeClause(): {
    LikeClause likeClause = new LikeClause();
    Table table;
    List<SelectItem<Column>> columnsList;
} {
    <K_LIKE>
    table = Table() { likeClause.setTable(table); }
    [ "(" columnsList = ColumnSelectItemsList() ")" { likeClause.setColumnsList(columnsList); }]

    [
        LOOKAHEAD(2)
        (
              <K_INCLUDING> { likeClause.setIncludingDefaults(true); }
            | <K_EXCLUDING> { likeClause.setExcludingDefaults(true); }
        )
        <K_DEFAULTS>
    ]

    [
        LOOKAHEAD(2)
        (
              <K_INCLUDING> { likeClause.setIncludingIdentity(true); }
            | <K_EXCLUDING> { likeClause.setExcludingIdentity(true); }
        )
        <K_IDENTITY>
    ]

    [
        LOOKAHEAD(2)
        (
              <K_INCLUDING> { likeClause.setIncludingComments(true); }
            | <K_EXCLUDING> { likeClause.setExcludingComments(true); }
        )
        <K_COMMENTS>
    ]

    {
        return likeClause;
    }
}

Export Export() #Export: {
    Export export = new Export();
    Table table;
    ParenthesedExpressionList<Column> columns;
    ParenthesedSelect select;
    ExportIntoItem exportIntoItem;
} {
    <K_EXPORT>
    (
          table = Table() { export.setTable(table); }
          [ columns = ParenthesedColumnList() { export.setColumns(columns); } ]
        | select = ParenthesedSelect() { export.setSelect(select); }
    )

    <K_INTO>
    exportIntoItem = ExportIntoItem() { export.setExportIntoItem(exportIntoItem); }

    {
        return export;
    }
}

Import Import() #Import: {
    Import impt = new Import();
    Table table;
    ParenthesedExpressionList<Column> columns;
    List<ImportColumn> importColumns;
    ImportFromItem fromItem;
} {
    <K_IMPORT>
    [
        <K_INTO>
        (
              table = Table() { impt.setTable(table); }
              [ columns = ParenthesedColumnList() { impt.setColumns(columns); } ]
            | importColumns = ImportColumns() { impt.setImportColumns(importColumns); }
        )
    ]

    <K_FROM>
    fromItem = ImportFromItem() { impt.setFromItem(fromItem); }

    {
        return impt;
    }
}

Import SubImport() #SubImport: {
    Import impt = new Import();
    List<ImportColumn> importColumns;
    ImportFromItem fromItem;
} {
    "("
        <K_IMPORT>
        [ <K_INTO> importColumns = ImportColumns() { impt.setImportColumns(importColumns); } ]

        <K_FROM>
        fromItem = ImportFromItem() { impt.setFromItem(fromItem); }
    ")"

    {
        return impt;
    }
}

List<ImportColumn> ImportColumns(): {
    ImportColumn importColumn;
    List<ImportColumn> importColumns = new ArrayList<ImportColumn>();
} {
    "("
        (
              importColumn = ColumnDefinition()
            | importColumn = LikeClause()
        )
        { importColumns.add(importColumn); }

        (
            ","
            (
                  importColumn = ColumnDefinition()
                | importColumn = LikeClause()
            )
            { importColumns.add(importColumn); }
        )*
    ")"

    {
        return importColumns;
    }
}

ExportIntoItem ExportIntoItem(): {
    ExportIntoItem exportIntoItem;
    ErrorClause errorClause;
} {
    (
          exportIntoItem = DBMSDestination()
        | exportIntoItem = FileDestination()
        | exportIntoItem = ScriptSourceDestination()
    )
    [ LOOKAHEAD(2) errorClause = ErrorClause() { exportIntoItem.setErrorClause(errorClause); } ]

    {
        return exportIntoItem;
    }
}

ImportFromItem ImportFromItem(): {
    ImportFromItem importFromItem;
    ErrorClause errorClause;
} {
    (
          importFromItem = DBMSSource()
        | importFromItem = FileSource()
        | importFromItem = ScriptSourceDestination()
    )
    [ LOOKAHEAD(2) errorClause = ErrorClause() { importFromItem.setErrorClause(errorClause); } ]

    {
        return importFromItem;
    }
}

DBMSDestination DBMSDestination() #DBMSDestination: {
    DBMSDestination dbmsDestination = new DBMSDestination();
    DBMSType dbmsType;
    ConnectionDefinition connectionDefinition;
    Table table;
    ExpressionList<Column> columns;
    StringValue statement;
    List<DBMSTableDestinationOption> dbmsTableDestinationOptions;
} {
    dbmsType = DBMSType() { dbmsDestination.setDestinationType(dbmsType); }

    connectionDefinition = ConnectionDefinition() { dbmsDestination.setConnectionDefinition(connectionDefinition); }

    (
          LOOKAHEAD(3)
          <K_TABLE> table = Table() { dbmsDestination.setTable(table); }
          [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsDestination.setColumns(columns); } ]
          [ LOOKAHEAD(2) dbmsTableDestinationOptions = DBMSTableDestinationOptionList() { dbmsDestination.setDBMSTableDestinationOptions(dbmsTableDestinationOptions); } ]
        | statement = ImportExportStatement() { dbmsDestination.setStatement(statement); }
    )

    {
      return dbmsDestination;
    }
}

DBMSTableDestinationOption DBMSTableDestinationOption(): {
    DBMSTableDestinationOption dbmsTableDestinationOption;

    Token token;
    Token token2;
    Token token3;
} {
    (
        (
              token = <K_REPLACE>
            | token = <K_TRUNCATE>
            ) { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image); }
        | token = <K_CREATED> token2 = <K_BY> token3 = <S_CHAR_LITERAL> { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image + " " + token2.image, new StringValue(token3.image)); }
    )

    {
        return dbmsTableDestinationOption;
    }
}

List<DBMSTableDestinationOption> DBMSTableDestinationOptionList(): {
    List<DBMSTableDestinationOption> dbmsTableDestinationOptions = new ArrayList<DBMSTableDestinationOption>();
    DBMSTableDestinationOption dbmsTableDestinationOption;
} {
    ( LOOKAHEAD(2) dbmsTableDestinationOption = DBMSTableDestinationOption() { dbmsTableDestinationOptions.add(dbmsTableDestinationOption); } )+
    {
        return dbmsTableDestinationOptions;
    }
}

DBMSSource DBMSSource() #DBMSSource: {
    DBMSSource dbmsSource = new DBMSSource();
    DBMSType dbmsType;
    ConnectionDefinition connectionDefinition;
    Table table;
    ExpressionList<Column> columns;
    List<StringValue> statements;
} {
    dbmsType = DBMSType() { dbmsSource.setSourceType(dbmsType); }

    connectionDefinition = ConnectionDefinition() { dbmsSource.setConnectionDefinition(connectionDefinition); }

    (
          <K_TABLE> table = Table() { dbmsSource.setTable(table); }
          [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsSource.setColumns(columns); } ]
        | statements = ImportExportStatementsList() { dbmsSource.setStatements(statements); }
    )
    {
      return dbmsSource;
    }
}

DBMSType DBMSType(): {
    DBMSType dbmsType;
    Token tk1;
    Token tk2 = null;
} {
    (
        tk1=<K_EXA>
      | tk1=<K_ORA>
      | tk1=<K_JDBC>
        [<K_DRIVER> "=" tk2=<S_CHAR_LITERAL>]
    ) { dbmsType = new DBMSType(tk1.image, tk2 == null ? null : tk2.image); }
    {
        return dbmsType;
    }
}

FileType FileType(): {
    FileType fileType;
    Token tk;
} {
    (
        tk=<K_CSV>
      | tk=<K_FBV>
    ) { fileType = new FileType(tk.image); }
    {
        return fileType;
    }
}

StringValue ImportExportStatement() #ImportExportStatement: {
    StringValue statement;
} {
    <K_STATEMENT> token = <S_CHAR_LITERAL>
    {
      statement = new StringValue(token.image);
      linkAST(statement, jjtThis);
      return statement;
    }
}

List<StringValue> ImportExportStatementsList(): {
    List<StringValue> statements = new ArrayList<StringValue>();
    StringValue statement;
} {
    ( statement = ImportExportStatement() { statements.add(statement); } )+

    {
        return statements;
    }
}

StringValue File() #File: {
    Token token;
} {
    <K_FILE> token = <S_CHAR_LITERAL>
    {
        StringValue file = new StringValue(token.image);
        linkAST(file, jjtThis);
        return file;
    }
}

List<StringValue> FileList(): {
    List<StringValue> files = new ArrayList<StringValue>();
    StringValue file;
} {
    ( file = File() { files.add(file); } )+
    {
        return files;
    }
}

ConnectionFileDefinition ConnectionFileDefinition(): {
    ConnectionDefinition connectionDefinition = null;
    List<StringValue> files;
} {
    connectionDefinition = ConnectionOrCloudConnectionDefinition()
    files = FileList()
    {
        return new ConnectionFileDefinition(connectionDefinition, files);
    }
}

List<ConnectionFileDefinition> ConnectionFileDefinitionList(): {
    List<ConnectionFileDefinition> connectionFileDefinitions = new ArrayList<ConnectionFileDefinition>();
    ConnectionFileDefinition connectionFileDefinition;
} {
    ( LOOKAHEAD(2) connectionFileDefinition = ConnectionFileDefinition() { connectionFileDefinitions.add(connectionFileDefinition); } )+
    {
        return connectionFileDefinitions;
    }
}

CSVColumn CSVDestinationColumn(): {
    CSVColumn csvColumn;

    Token token;
    Token token2;
} {
    (
          LOOKAHEAD(2)
          token=<S_LONG> ".." token2=<S_LONG> { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); }
        | token=<S_LONG> { csvColumn = new CSVColumn(Long.valueOf(token.image)); }
          [ <K_FORMAT> "=" token = <S_CHAR_LITERAL> { csvColumn.setFormat(new StringValue(token.image)); }]
          [
            <K_DELIMIT>
            "="
            (
                  token=<K_ALWAYS>
                | token=<K_NEVER>
                | token=<K_AUTO>
            )
            { csvColumn.setDelimit(token.image); }
          ]
    )
    {
        return csvColumn;
    }
}

List<CSVColumn> CSVDestinationColumnList(): {
    List<CSVColumn> csvColumns = new ArrayList<CSVColumn>();
    CSVColumn csvColumn;
} {
    csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); }
    ( "," csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); } )*
    {
        return csvColumns;
    }
}

CSVColumn CSVSourceColumn(): {
    CSVColumn csvColumn;

    Token token;
    Token token2;
} {
    (
          LOOKAHEAD(2)
          token=<S_LONG> ".." token2=<S_LONG> { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); }
        | token=<S_LONG> { csvColumn = new CSVColumn(Long.valueOf(token.image)); }
          [ <K_FORMAT> "=" token = <S_CHAR_LITERAL> { csvColumn.setFormat(new StringValue(token.image)); }]
    )
    {
        return csvColumn;
    }
}

List<CSVColumn> CSVSourceColumnList(): {
    List<CSVColumn> csvColumns = new ArrayList<CSVColumn>();
    CSVColumn csvColumn;
} {
    csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); }
    ( "," csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); } )*
    {
        return csvColumns;
    }
}

FBVColumn FBVDestinationColumn(): {
    FBVColumn fbvColumn;

    Token token;
    Token token2;
} {
    (
          token=<K_SIZE> "=" token2=<S_LONG> { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); }
        | ( token=<K_FORMAT> | token=<K_PADDING> ) "=" token2=<S_CHAR_LITERAL> { fbvColumn = new FBVColumn(token.image, new StringValue(token2.image)); }
        | token=<K_ALIGN> "=" ( token2=<K_LEFT> | token2=<K_RIGHT> ) { fbvColumn = new FBVColumn(token.image, token2.image); }
    )
    {
        return fbvColumn;
    }
}

List<FBVColumn> FBVDestinationColumnList(): {
    List<FBVColumn> fbvColumns = new ArrayList<FBVColumn>();
    FBVColumn fbvColumn;
    boolean precedesComma;
} {
    fbvColumn = FBVDestinationColumn() { fbvColumns.add(fbvColumn); }
    (
        { precedesComma = false; }
        ["," { precedesComma = true; }]
        fbvColumn = FBVDestinationColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); }
    )*
    {
        return fbvColumns;
    }
}

FBVColumn FBVSourceColumn(): {
    FBVColumn fbvColumn;

    Token token;
    Token token2;
} {
    (
          ( token=<K_SIZE> | token=<K_START> ) "=" token2=<S_LONG> { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); }
        | ( token=<K_FORMAT> | token=<K_PADDING> ) "=" token2=<S_CHAR_LITERAL> { fbvColumn = new FBVColumn(token.image, new StringValue(token2.image)); }
        | token=<K_ALIGN> "=" ( token2=<K_LEFT> | token2=<K_RIGHT> ) { fbvColumn = new FBVColumn(token.image, token2.image); }
    )
    {
        return fbvColumn;
    }
}

List<FBVColumn> FBVSourceColumnList(): {
    List<FBVColumn> fbvColumns = new ArrayList<FBVColumn>();
    FBVColumn fbvColumn;
    boolean precedesComma;
} {
    fbvColumn = FBVSourceColumn() { fbvColumns.add(fbvColumn); }
    (
        { precedesComma = false; }
        ["," { precedesComma = true; }]
        fbvColumn = FBVSourceColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); }
    )*
    {
        return fbvColumns;
    }
}

FileOption FileDestinationOption(): {
    FileOption fileOption;

    Token token;
    Token token2;
    Token token3;
} {
    (
        ( token=<K_REPLACE> | token=<K_TRUNCATE> ) { fileOption = new FileOption(token.image); }
      | token=<K_WITH> token2=<K_COLUMN> token3=<K_NAMES> { fileOption = new FileOption(token.image + " " + token2.image + " " + token3.image); }
      | ( token=<K_ENCODING> | token=<K_NULL> | token=<K_BOOLEAN> ) "=" token2=<S_CHAR_LITERAL> { fileOption = new FileOption(token.image, new StringValue(token2.image)); }
      | (
            token=<K_ROW> token2=<K_SEPARATOR> "=" token3=<S_CHAR_LITERAL>
          | token=<K_COLUMN> ( token2=<K_SEPARATOR> | token2=<K_DELIMITER> ) "=" token3=<S_CHAR_LITERAL>
        )
        { fileOption = new FileOption(token.image + " " + token2.image, new StringValue(token3.image)); }
      | token=<K_DELIMIT> "=" ( token2=<K_ALWAYS> | token2=<K_NEVER> | token2=<K_AUTO> ) { fileOption = new FileOption(token.image, token2.image); }
    )
    {
        return fileOption;
    }
}

List<FileOption> FileDestinationOptionList(): {
    List<FileOption> fileOptions = new ArrayList<FileOption>();
    FileOption fileOption;
} {
    ( LOOKAHEAD(2) fileOption = FileDestinationOption() { fileOptions.add(fileOption); } )+
    {
        return fileOptions;
    }
}

FileOption FileSourceOption(): {
    FileOption fileOption;

    Token token;
    Token token2;
    Token token3;
} {
    (
        ( token=<K_TRIM> | token=<K_LTRIM> | token=<K_RTRIM> ) { fileOption = new FileOption(token.image); }
      | (
            ( token=<K_ENCODING> | token=<K_NULL> ) "=" token2=<S_CHAR_LITERAL> { fileOption = new FileOption(token.image, new StringValue(token2.image)); }
          | token=<K_SKIP> "=" token2=<S_LONG> { fileOption = new FileOption(token.image, new LongValue(token2.image)); }
        )
      | LOOKAHEAD(2)
        (
            token=<K_ROW> token2=<K_SEPARATOR> "=" token3=<S_CHAR_LITERAL>
          | token=<K_COLUMN> ( token2=<K_SEPARATOR> | token2=<K_DELIMITER> ) "=" token3=<S_CHAR_LITERAL>
        )
        { fileOption = new FileOption(token.image + " " + token2.image, new StringValue(token3.image)); }
      | token=<K_ROW> token2=<K_SIZE> "=" token3=<S_LONG>
        { fileOption = new FileOption(token.image + " " + token2.image, new LongValue(token3.image)); }
    )
    {
        return fileOption;
    }
}

List<FileOption> FileSourceOptionList(): {
    List<FileOption> fileOptions = new ArrayList<FileOption>();
    FileOption fileOption;
} {
    ( LOOKAHEAD(2) fileOption = FileSourceOption() { fileOptions.add(fileOption); } )+
    {
        return fileOptions;
    }
}

FileDestination FileDestination() #FileDestination: {
    FileDestination fileDestination = new FileDestination();
    FileType fileType;
    List<ConnectionFileDefinition> connectionFileDefinitions;
    List<StringValue> files;
    List<CSVColumn> csvColumns;
    List<FBVColumn> fbvColumns;
    List<FileOption> fileOptions;
    CertificateVerification certificateVerification;
} {
  (
      fileType = FileType() { fileDestination.setDestinationType(fileType); }
      connectionFileDefinitions = ConnectionFileDefinitionList() { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); }
    | <K_LOCAL> { fileDestination.setLocal(true); }
      [<K_SECURE> { fileDestination.setSecure(true); }]

      fileType = FileType() { fileDestination.setDestinationType(fileType); }
      files = FileList()
      {
            connectionFileDefinitions = new ArrayList<ConnectionFileDefinition>();
            connectionFileDefinitions.add(new ConnectionFileDefinition(files));
      }
  )
  { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); }

  [
    LOOKAHEAD(2)
    "("
        (
            csvColumns = CSVDestinationColumnList() { fileDestination.setCSVColumns(csvColumns); }
          | fbvColumns = FBVDestinationColumnList() { fileDestination.setFBVColumns(fbvColumns); }
        )
    ")"
  ]

  [ LOOKAHEAD(2) fileOptions = FileDestinationOptionList() { fileDestination.setFileOptions(fileOptions); } ]

  [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileDestination.setCertificateVerification(certificateVerification); } ]

  {
    return fileDestination;
  }
}

FileSource FileSource() #FileSource: {
    FileSource fileSource = new FileSource();
    FileType fileType;
    List<ConnectionFileDefinition> connectionFileDefinitions;
    List<StringValue> files;
    List<CSVColumn> csvColumns;
    List<FBVColumn> fbvColumns;
    List<FileOption> fileOptions;
    CertificateVerification certificateVerification;
} {
  (
      fileType = FileType() { fileSource.setSourceType(fileType); }
      connectionFileDefinitions = ConnectionFileDefinitionList() { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); }
    | <K_LOCAL> { fileSource.setLocal(true); }
      [<K_SECURE> { fileSource.setSecure(true); }]

      fileType = FileType() { fileSource.setSourceType(fileType); }
      files = FileList()
      {
            connectionFileDefinitions = new ArrayList<ConnectionFileDefinition>();
            connectionFileDefinitions.add(new ConnectionFileDefinition(files));
      }
  )
  { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); }

  [
    LOOKAHEAD(2)
    "("
        (
            csvColumns = CSVSourceColumnList() { fileSource.setCSVColumns(csvColumns); }
          | fbvColumns = FBVSourceColumnList() { fileSource.setFBVColumns(fbvColumns); }
        )
    ")"
  ]

  [ LOOKAHEAD(2) fileOptions = FileSourceOptionList() { fileSource.setFileOptions(fileOptions); } ]

  [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileSource.setCertificateVerification(certificateVerification); } ]

  {
    return fileSource;
  }
}

CertificateVerification CertificateVerification(): {
    CertificateVerification certificateVerification = new CertificateVerification();
    Token token;
} {
    (
          (
                <K_IGNORE> { certificateVerification.setIgnoreCertificate(true); }
              | <K_VERIFY> { certificateVerification.setVerifyCertificate(true); }
          )
          <K_CERTIFICATE>
          [
            LOOKAHEAD(2)
            <K_PUBLIC> <K_KEY>
            token = <S_CHAR_LITERAL> { certificateVerification.setPublicKey(new StringValue(token.image)); }
          ]
        | <K_PUBLIC> <K_KEY>
          token = <S_CHAR_LITERAL> { certificateVerification.setPublicKey(new StringValue(token.image)); }
    )
    {
        return certificateVerification;
    }
}

ScriptSourceDestination ScriptSourceDestination(): {
  ScriptSourceDestination scriptSourceDestination = new ScriptSourceDestination();
  ConnectionDefinition connectionDefinition;
  Table script;
  String property;
  StringValue value;

  Token token;
} {
    <K_SCRIPT>
    script = Table() { scriptSourceDestination.setScript(script); }

    [ LOOKAHEAD(2) connectionDefinition = ConnectionDefinition() { scriptSourceDestination.setConnectionDefinition(connectionDefinition); } ]

    [
        LOOKAHEAD(2)
        {
            List<String> properties = new ArrayList<String>();
            List<StringValue> values = new ArrayList<StringValue>();
            scriptSourceDestination.setProperties(properties);
            scriptSourceDestination.setValues(values);
        }

        <K_WITH>
        (
            LOOKAHEAD(2)
            property = RelObjectName() "=" token = <S_CHAR_LITERAL> { value = new StringValue(token.image); }
            {
                properties.add(property);
                values.add(value);
            }
        )+
    ]

    {
      return scriptSourceDestination;
    }
}

UserIdentification UserIdentification(): {
    UserIdentification userIdentification = new UserIdentification();
    Token token;
} {
    <K_USER>
    token=<S_CHAR_LITERAL> { userIdentification.setUser(new StringValue(token.image)); }
    <K_IDENTIFIED> <K_BY>
    token=<S_CHAR_LITERAL> { userIdentification.setPassword(new StringValue(token.image)); }

    {
        return userIdentification;
    }
}

ConnectionDefinition ConnectionDefinition(): {
  ConnectionDefinition connectionDefinition = new ConnectionDefinition();
  String connectionObjectName;
  UserIdentification userIdentification;
  CertificateVerification certificateVerification;

  Token token;
} {
  <K_AT>
  (
      connectionObjectName = RelObjectName() { connectionDefinition.setConnectionObjectName(connectionObjectName); }
    | token=<S_CHAR_LITERAL> { connectionDefinition.setConnectionDefinition(new StringValue(token.image)); }
  )

  [ LOOKAHEAD(2) userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ]

  [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { connectionDefinition.setCertificateVerification(certificateVerification); } ]

  {
      return connectionDefinition;
  }
}

ConnectionDefinition CloudConnectionDefinition(): {
  CloudConnectionDefinition connectionDefinition = new CloudConnectionDefinition();
  String connectionObjectName;
  UserIdentification userIdentification;

  Token token;
  Token token2;
} {
  <K_AT> <K_CLOUD>
  (
      token = <K_NONE> { connectionDefinition.setStorage(token.image); }
    | token = <K_AZURE> token2 = <K_BLOBSTORAGE> { connectionDefinition.setStorage(token.image + " " + token2.image); }
  )

  (
      connectionObjectName = RelObjectName() { connectionDefinition.setConnectionObjectName(connectionObjectName); }
    | token = <S_CHAR_LITERAL> { connectionDefinition.setConnectionDefinition(new StringValue(token.image)); }
  )

  [ userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ]

  {
      return connectionDefinition;
  }
}

ConnectionDefinition ConnectionOrCloudConnectionDefinition(): {
    ConnectionDefinition connectionDefinition;
} {
    (
        LOOKAHEAD(2) connectionDefinition = CloudConnectionDefinition()
      | connectionDefinition = ConnectionDefinition()
    )
    {
        return connectionDefinition;
    }
}

ErrorClause ErrorClause(): {
  ErrorClause errorClause = new ErrorClause();
  ErrorDestination errorDestination;
  Expression expression;
  RejectClause rejectClause;

  Token token;
} {
    (
        <K_ERRORS> <K_INTO>
        errorDestination = ErrorDestination() { errorClause.setErrorDestination(errorDestination); }
        [
          LOOKAHEAD(2)
          "("
          expression = Expression() { errorClause.setExpression(expression); }
          ")"
        ]
        [
            LOOKAHEAD(2)
            (
                <K_REPLACE> { errorClause.setReplace(true); }
              | <K_TRUNCATE> { errorClause.setTruncate(true); }
            )
        ]
        [ LOOKAHEAD(2) rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); } ]
      | rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); }
  )

  {
    return errorClause;
  }
}

RejectClause RejectClause(): {
    RejectClause rejectClause = new RejectClause();
} {
    <K_REJECT> <K_LIMIT>
    (
          token=<S_LONG> { rejectClause.setLimit(new LongValue(token.image)); }
        | <K_UNLIMITED>
    )

    [ LOOKAHEAD(2) <K_ERRORS> { rejectClause.setErrors(true); } ]

    {
        return rejectClause;
    }
}

ErrorDestination ErrorDestination(): {
    ErrorDestination errorDestination;
} {
    (
          LOOKAHEAD(2) errorDestination = CSVFileDestination()
        | errorDestination = Table()
    )

    {
        return errorDestination;
    }
}

CSVFileDestination CSVFileDestination(): {
    CSVFileDestination csvFileDestination = new CSVFileDestination();
    ConnectionDefinition connectionDefinition;
    StringValue file;
} {
    (
          <K_CSV>
          connectionDefinition = ConnectionOrCloudConnectionDefinition() { csvFileDestination.setConnectionDefinition(connectionDefinition); }
        | <K_LOCAL> { csvFileDestination.setLocal(true); }
          [ <K_SECURE> { csvFileDestination.setSecure(true); } ]
          <K_CSV>
    )

    file = File() { csvFileDestination.setFile(file); }

    {
        return csvFileDestination;
    }
}

DeclareStatement Declare(): {
    UserVariable userVariable;
    ColDataType colDataType;
    Expression defaultExpr = null;
    DeclareStatement stmt = new DeclareStatement();
    String typeName;
    String columnName;
    ColumnDefinition colDef;
} {
    <K_DECLARE> userVariable = UserVariable()
    (
         LOOKAHEAD(2) (
            <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;
    }
}

SessionStatement SessionStatement():
{
    SessionStatement sessionsStatement;
    Token actionToken;
    Token idToken = null;
    String id = null;
}
{
    ( <K_SESSION> | <K_BRANCH> )
    (
        actionToken = <K_START>
        |
        actionToken = <K_APPLY>
        |
        actionToken = <K_DROP>
        |
        actionToken = <K_SHOW>
        |
        actionToken = <K_DESCRIBE>
    )

    [
        (
            idToken = <S_IDENTIFIER>
            |
            idToken = <S_QUOTED_IDENTIFIER>
            |
            idToken = <S_CHAR_LITERAL>
            |
            idToken = <S_LONG>
        ) { id = idToken.image; }

        (
            "."
            (
                idToken = <S_IDENTIFIER>
                |
                idToken = <S_QUOTED_IDENTIFIER>
                |
                idToken = <S_CHAR_LITERAL>
                |
                idToken = <S_LONG>
            ) { id += "." + idToken.image; }
        )?
    ]
    {
        sessionsStatement = id!=null
            ? new SessionStatement(actionToken.image, id)
            : new SessionStatement(actionToken.image);
    }

    // options
    [
        LOOKAHEAD(2) <K_WITH>
        ( idToken = <S_IDENTIFIER> | idToken = <K_KEEP> )
        "="
        ( actionToken = <S_IDENTIFIER> | actionToken = <S_QUOTED_IDENTIFIER> | actionToken = <S_CHAR_LITERAL> | actionToken = <S_LONG> | actionToken = <K_TRUE> | actionToken = <K_FALSE> | actionToken = <K_ON> | actionToken = <K_OFF>  | actionToken = <K_YES> | actionToken = <K_NO> )
        { sessionsStatement.putOption(idToken.image, actionToken.image ); }

        (
            ","
            ( idToken = <S_IDENTIFIER> | idToken = <K_KEEP> )
            "="
            ( actionToken = <S_IDENTIFIER> | actionToken = <S_QUOTED_IDENTIFIER> | actionToken = <S_CHAR_LITERAL> | actionToken = <S_LONG> | actionToken = <K_TRUE> | actionToken = <K_FALSE> | actionToken = <K_ON> | actionToken = <K_OFF>  | actionToken = <K_YES> | actionToken = <K_NO> )
            { sessionsStatement.putOption(idToken.image, actionToken.image ); }
        )*
    ]

    {
        //linkAST(sessionsStatement,jjtThis);
        return sessionsStatement;
    }
}

SetStatement Set(): {
    String namePart;
    Object name;
    ExpressionList 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 = UserVariable() ["=" { useEqual=true; } ]
        )
        |
        (
            name = IdentifierChain()
            ["=" { useEqual=true; } ]
        )
    )
    exp=Expression()
    {
        expList = new ExpressionList();
        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 = RelObjectName() ["=" { useEqual=true; } ])
                )
                exp=Expression()
                {
                    expList = new ExpressionList();
                    expList.add(exp);
                    set.add(name, expList, useEqual);
                }
            )
            |
            exp=Expression() { 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;
    DescribeStatement stmt = new DescribeStatement();
    Token tk = null;
} {
    (tk=<K_DESCRIBE> | tk=<K_DESC>)
    table = Table() { stmt.setDescribeType(tk.image).setTable(table); }
    {
        return stmt;
    }
}

ExplainStatement Explain():
{
    Token tk;
    Statement statement;
    List<WithItem<?>> with = null;
    Table table;
    List<ExplainStatement.Option> options;
    ExplainStatement es;
}
{
    ( tk=<K_EXPLAIN> | tk = <K_SUMMARIZE> )
    (
        LOOKAHEAD(3)(
            options= ExplainStatementOptions()
            (
                [ LOOKAHEAD(2) with=WithList() ]
                (
                    statement = SelectWithWithItems( with )
                    | statement = InsertWithWithItems( with )
                    | statement = UpdateWithWithItems( with )
                    | statement = DeleteWithWithItems( with )
                    | statement = Merge( with )
                )
            )
            {
                es = new ExplainStatement(tk.image, statement, options);
            }
        )
        |
        (
           table=Table( ) {  es = new ExplainStatement(tk.image, table);  }
        )
    )
    {
        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);
      }
    )
    |
    (
        <K_PLAN> { option = new ExplainStatement.Option(ExplainStatement.OptionType.PLAN); }
        [ <K_FOR> { option = new ExplainStatement.Option(ExplainStatement.OptionType.PLAN_FOR); } ]

        value=ExplainFormatOption()
        {
            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 = RelObjectName()
    {
        return new UseStatement(name, hasSchemaKeyword);
    }
}

Statement Show():
{
    Statement statement;
    List<String> captureRest;
}
{
    <K_SHOW>
    (
        LOOKAHEAD(2) statement = ShowColumns()
        |
        LOOKAHEAD(2) statement = ShowIndex()
        |
        LOOKAHEAD(2) statement = ShowTables()
        |
        // any of the RDBMS specific SHOW syntax
        captureRest = captureRest()
        {
            if (captureRest.size()==1) {
                statement = new ShowStatement(captureRest.get(0));
            } else {
                statement = new UnsupportedStatement("SHOW", captureRest);
            }
        }
    )
    {
        return statement;
    }
}

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

ShowIndexStatement ShowIndex(): {
    String tableName;
}
{
    <K_INDEX> <K_FROM> tableName = RelObjectName()
    {
        return new ShowIndexStatement(tableName);
    }
}

Statement RefreshMaterializedView(): {
    Table view = null;
    boolean concurrently = false;
    RefreshMode refreshMode = null;
    List<String> captureRest;
}
{
    <K_REFRESH> <K_MATERIALIZED> <K_VIEW>
    [ LOOKAHEAD(2) <K_CONCURRENTLY>  { concurrently = true; } ]
    view = Table()
    [
        <K_WITH> { refreshMode = RefreshMode.WITH_DATA; }
        [
            <K_NO> { refreshMode = RefreshMode.WITH_NO_DATA; }
        ]
        <K_DATA>
    ]
    captureRest = captureRest()
    {
        if (concurrently && refreshMode == RefreshMode.WITH_NO_DATA) {
            return new UnsupportedStatement("REFRESH", captureRest);
        } else {
           return new RefreshMaterializedViewStatement(view, concurrently, refreshMode);
        }
    }
}
// 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_EXTENDED> { modifiers.add(ShowTablesStatement.Modifiers.EXTENDED); } ]
  [ <K_FULL> { modifiers.add(ShowTablesStatement.Modifiers.FULL); } ]
  <K_TABLES>
  [
    LOOKAHEAD(2) (
        <K_FROM> { selectionMode = ShowTablesStatement.SelectionMode.FROM; }
        |
        <K_IN> { selectionMode = ShowTablesStatement.SelectionMode.IN; }
    )
    dbName = RelObjectName()
  ]
  [ (<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;
  }
}

Values Values(): {
    ExpressionList expressions;
} {
    ( <K_VALUES> | <K_VALUE> )
    expressions = ExpressionList()

    {
        return new Values(expressions);
    }
}

ReturningClause ReturningClause():
{
    Token keyword;
    List<ReturningOutputAlias> outputAliases = null;
    List<SelectItem<?>> selectItems;
    Object dataItem;
    List<Object> dataItems = null;
}
{
    ( keyword=<K_RETURNING> | keyword=<K_RETURN> )
    [ LOOKAHEAD(2) outputAliases = ReturningOutputAliasList() ]
    selectItems = SelectItemsList()

    [
        <K_INTO>
        ( dataItem = Table() | dataItem = UserVariable() )
        { dataItems = new ArrayList<Object>(); dataItems.add(dataItem); }

        (
            ","
            ( dataItem = Table() | dataItem = UserVariable() ) { dataItems.add(dataItem); }
        )*
    ]

    {
        return new ReturningClause(keyword.image, selectItems, outputAliases, dataItems);
    }
}

ReturningReferenceType ReturningReferenceKind():
{
    String refName;
    ReturningReferenceType refType;
}
{
    refName = RelObjectName()
    {
        refType = ReturningReferenceType.from(refName);
        if (refType == ReturningReferenceType.OLD) {
            return ReturningReferenceType.OLD;
        } else if (refType == ReturningReferenceType.NEW) {
            return ReturningReferenceType.NEW;
        }
        throw new ParseException("Expected OLD or NEW but found: " + refName);
    }
}

ReturningOutputAlias ReturningOutputAliasDefinition():
{
    ReturningReferenceType refType;
    String aliasName;
}
{
    refType = ReturningReferenceKind()
    <K_AS>
    aliasName = RelObjectName()
    {
        return new ReturningOutputAlias(refType, aliasName);
    }
}

List<ReturningOutputAlias> ReturningOutputAliasList():
{
    List<ReturningOutputAlias> outputAliases = new ArrayList<ReturningOutputAlias>();
    ReturningOutputAlias outputAlias;
}
{
    <K_WITH> "("
    outputAlias = ReturningOutputAliasDefinition() { outputAliases.add(outputAlias); }
    (
        ","
        outputAlias = ReturningOutputAliasDefinition() { outputAliases.add(outputAlias); }
    )*
    ")"
    {
        return outputAliases;
    }
}

Update UpdateWithWithItems( List<WithItem<?>> withItems ):
{
    Update update;
}
{
    update = Update() { update.setWithItemsList( withItems );
    return update;
}
}

Update Update():
{
    Update update = new Update();
    Table table = null;
    List<Join> startJoins = null;
    List<WithItem<?>> with = null;
    List<UpdateSet> updateSets;
    Expression where = null;
    PreferringClause preferringClause = null;
    FromItem fromItem = null;
    List<Join> joins = null;
    Limit limit = null;
    OptionClause optionClause = null;
    List<OrderByElement> orderByElements;
    boolean useColumnsBrackets = false;
    ReturningClause returningClause;
    Token tk = null;
    UpdateModifierPriority modifierPriority = null;
    boolean modifierIgnore = false;

    OutputClause outputClause = null;
}
{
   <K_UPDATE> { update.setOracleHint(getOracleHint()); }
    [ LOOKAHEAD(2) <K_LOW_PRIORITY> { modifierPriority = UpdateModifierPriority.LOW_PRIORITY; }]
    [ LOOKAHEAD(2) <K_IGNORE> { modifierIgnore = true; }]
    table=TableWithAliasAndMysqlIndexHint() [ startJoins=JoinsList() ]
    <K_SET> updateSets = UpdateSets() { update.setUpdateSets(updateSets); }

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

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

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

    [ orderByElements = OrderByElements() { update.setOrderByElements(orderByElements); } ]
    [ limit = PlainLimit() { update.setLimit(limit); } ]
    [ LOOKAHEAD(2) optionClause = OptionClause() { update.setOption(optionClause); } ]
    [ returningClause = ReturningClause() { update.setReturningClause(returningClause); } ]

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

List<UpdateSet> UpdateSets():
{
    ArrayList<UpdateSet> updateSets = new ArrayList<UpdateSet>();
    UpdateSet updateSet;
    Column tableColumn;
    Expression valueExpression;

    ExpressionList<Column> columns;
    ExpressionList<Expression>values;
}
{
    (
        (
            tableColumn=Column() "=" valueExpression=Expression()
            { updateSets.add( new UpdateSet (tableColumn, valueExpression)); }
        )
        |
        (
            { updateSet = new UpdateSet(); updateSets.add(updateSet); }
            columns = ParenthesedExpressionList() { updateSet.setColumns(columns); }
            "="
            (
                LOOKAHEAD(3) valueExpression = ParenthesedSelect() { updateSet.setValues( new ExpressionList(valueExpression)); }
                |
                values = ParenthesedExpressionList() { updateSet.setValues(values); }
            )
        )
    )

    (
        LOOKAHEAD(2) (
            ","
            tableColumn=Column() "=" valueExpression=Expression()
            { updateSets.add( new UpdateSet (tableColumn, valueExpression)); }
            |
            (
                { updateSet = new UpdateSet(); updateSets.add(updateSet); }
                columns = ParenthesedExpressionList() { updateSet.setColumns(columns); }
                "="
                (
                    LOOKAHEAD(3) valueExpression = ParenthesedSelect() { updateSet.setValues( new ExpressionList(valueExpression)); }
                    |
                    values = ParenthesedExpressionList() { updateSet.setValues(values); }
                )
            )
        )
    )*

    {
        return updateSets;
    }
}

List<Partition> Partitions():
{
    List<Partition> partitions = new ArrayList<Partition>();
    Column tableColumn;
    Expression valueExpression = null;
}
{
    (
        (
            tableColumn=Column() [ "=" valueExpression=Expression() ]
            { partitions.add( new Partition (tableColumn, valueExpression)); }
        )
    )

    (
        LOOKAHEAD(2) (
            ","
            tableColumn=Column() [ "=" valueExpression=Expression() ]
            { partitions.add( new Partition (tableColumn, valueExpression)); }
        )
    )*

    {
        return partitions;
    }
}

Insert InsertWithWithItems( List<WithItem<?>> withItems ):
{
    Insert insert;
}
{
    insert = Insert() { insert.setWithItemsList( withItems );
    return insert;
}
}

Insert Insert():
{
    Insert insert = new Insert();
    Table table = null;
    List<WithItem<?>> with = null;
    Column tableColumn = null;
    ExpressionList<Column> columns = new ExpressionList<Column>();
    List<Partition> partitions = new ArrayList<Partition>();
    Expression exp = null;
    ReturningClause returningClause;
    Select select = null;
    Token tk = null;
    InsertModifierPriority modifierPriority = null;
    boolean modifierIgnore = false;

    List<UpdateSet> updateSets;
    List<UpdateSet> duplicateUpdateSets;

    String name = null;
    boolean useAs = false;
    boolean useSet = false;
    Alias rowAlias = null;
    OutputClause outputClause = null;

    InsertConflictTarget conflictTarget = null;
    InsertConflictAction conflictAction = null;

    InsertDuplicateAction duplicateAction = null;
    Token multiInsertToken = null;
    List<OracleMultiInsertBranch> oracleMultiInsertBranches = new ArrayList<OracleMultiInsertBranch>();
    OracleMultiInsertClause oracleMultiInsertClause = null;
    OracleMultiInsertBranch oracleMultiInsertBranch = null;
}
{
    <K_INSERT> { insert.setOracleHint(getOracleHint()); }

    [
        LOOKAHEAD(2) (tk = <K_LOW_PRIORITY> | tk = <K_DELAYED> | tk = <K_HIGH_PRIORITY>)
        {
            if (tk!=null)
            modifierPriority = InsertModifierPriority.from(tk.image);
        }
    ]
    [ LOOKAHEAD(2) <K_IGNORE>{ modifierIgnore = true; }]
    (
        LOOKAHEAD(2, (<K_ALL> | <K_FIRST>) (<K_INTO> | <K_WHEN>))
        (
            (multiInsertToken = <K_ALL> | multiInsertToken = <K_FIRST>) {
                insert.setOracleMultiInsert(true);
                insert.setOracleMultiInsertFirst(multiInsertToken.kind == K_FIRST);
            }
            (
                {
                    oracleMultiInsertBranch = new OracleMultiInsertBranch();
                }
                oracleMultiInsertClause = OracleMultiInsertClause() {
                    oracleMultiInsertBranch.addClause(oracleMultiInsertClause);
                    table = oracleMultiInsertClause.getTable();
                }
                (
                    oracleMultiInsertClause = OracleMultiInsertClause() {
                        oracleMultiInsertBranch.addClause(oracleMultiInsertClause);
                    }
                )*
                {
                    oracleMultiInsertBranches.add(oracleMultiInsertBranch);
                }
                |
                (
                    (
                        oracleMultiInsertBranch = OracleMultiInsertWhenBranch() {
                            if (table == null && !oracleMultiInsertBranch.getClauses().isEmpty()) {
                                table = oracleMultiInsertBranch.getClauses().get(0).getTable();
                            }
                            oracleMultiInsertBranches.add(oracleMultiInsertBranch);
                        }
                    )+
                    [
                        oracleMultiInsertBranch = OracleMultiInsertElseBranch() {
                            if (table == null && !oracleMultiInsertBranch.getClauses().isEmpty()) {
                                table = oracleMultiInsertBranch.getClauses().get(0).getTable();
                            }
                            oracleMultiInsertBranches.add(oracleMultiInsertBranch);
                        }
                    ]
                )
            )
            select = Select() {
                insert.setOracleMultiInsertBranches(oracleMultiInsertBranches);
            }
        )
        |
        (
            [ LOOKAHEAD(2) (
                <K_OVERWRITE> <K_TABLE> { insert.setOverwrite(true); insert.setTableKeyword(true); }
                | <K_INTO> [ LOOKAHEAD(2) <K_TABLE> { insert.setTableKeyword(true); }]
                )
            ]   table=Table()
            [ LOOKAHEAD(2) <K_PARTITION> "(" partitions=Partitions() ")" ]

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

            [ LOOKAHEAD(2) "(" columns=ColumnList() ")"  ]

            [ LOOKAHEAD(2) <K_OVERRIDING> <K_SYSTEM> <K_VALUE> { insert.setOverriding(true); } ]

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

            (
                <K_DEFAULT> <K_VALUES> { insert.setOnlyDefaultValues(true); }
                |
                (
                    <K_SET> updateSets = UpdateSets() { insert.withSetUpdateSets(updateSets); useSet = true; }
                )
                |
                select = Select()
            )

            [ LOOKAHEAD({ isAliasAhead() && (select instanceof Values || useSet) }) rowAlias = Alias() {
                if (select instanceof Values) {
                    select.setAlias(rowAlias);
                } else {
                    insert.setRowAlias(rowAlias);
                }
            } ]

            [ LOOKAHEAD(2) <K_ON> <K_DUPLICATE> <K_KEY> <K_UPDATE>
                         duplicateAction = InsertDuplicateAction() { insert.setDuplicateAction(duplicateAction); }
            ]

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

            [ returningClause = ReturningClause() { insert.setReturningClause(returningClause); } ]
        )
    )

    {
        if (!columns.isEmpty()) {
            insert.setColumns(columns);
        }
        if (!partitions.isEmpty()) {
            insert.setPartitions(partitions);
        }
        return insert.withWithItemsList(with)
              .withSelect(select)
              .withTable(table)
              .withModifierPriority(modifierPriority)
              .withModifierIgnore(modifierIgnore);
    }
}

OracleMultiInsertClause OracleMultiInsertClause():
{
    OracleMultiInsertClause clause = new OracleMultiInsertClause();
    Table clauseTable = null;
    ExpressionList<Column> clauseColumns = new ExpressionList<Column>();
    Select clauseSelect = null;
}
{
    <K_INTO> clauseTable=Table()
    [ LOOKAHEAD(2) "(" clauseColumns=ColumnList() ")" ]
    clauseSelect = Select()
    {
        if (!clauseColumns.isEmpty()) {
            clause.setColumns(clauseColumns);
        }
        return clause.withTable(clauseTable).withSelect(clauseSelect);
    }
}

OracleMultiInsertBranch OracleMultiInsertWhenBranch():
{
    Expression whenExpression = null;
    List<OracleMultiInsertClause> clauses = null;
}
{
    <K_WHEN> whenExpression = Expression() <K_THEN>
    clauses = OracleMultiInsertClauseList()
    {
        return new OracleMultiInsertBranch()
                .withWhenExpression(whenExpression)
                .withClauses(clauses);
    }
}

OracleMultiInsertBranch OracleMultiInsertElseBranch():
{
    List<OracleMultiInsertClause> clauses = null;
}
{
    <K_ELSE>
    clauses = OracleMultiInsertClauseList()
    {
        return new OracleMultiInsertBranch()
                .withElseClause(true)
                .withClauses(clauses);
    }
}

List<OracleMultiInsertClause> OracleMultiInsertClauseList():
{
    List<OracleMultiInsertClause> clauses = new ArrayList<OracleMultiInsertClause>();
    OracleMultiInsertClause clause = null;
}
{
    clause = OracleMultiInsertClause() {
        clauses.add(clause);
    }
    (
        clause = OracleMultiInsertClause() {
            clauses.add(clause);
        }
    )*
    {
        return clauses;
    }
}

InsertConflictTarget  InsertConflictTarget():
{
    String indexColumnName;
    ArrayList<String> indexColumnNames = new ArrayList<String>();
    Expression indexExpression = null;
    Expression whereExpression = null;
    String constraintName = null ;
}
{
    (
        (
            "("
            indexColumnName = RelObjectNameExt() { indexColumnNames.add(indexColumnName); }
            ( "," indexColumnName = RelObjectNameExt() { indexColumnNames.add(indexColumnName); } )*
//            |
//            (
//                "(" indexExpression = Expression() ")"
//            )

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

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

InsertConflictAction InsertConflictAction():
{
    InsertConflictAction conflictAction;
    Expression whereExpression = null;
    List<UpdateSet> updateSets;
}
{
    (
        LOOKAHEAD(2) (
            <K_DO> <K_NOTHING> { conflictAction = new InsertConflictAction( ConflictActionType.DO_NOTHING ); }
        )
        |
        (
            <K_DO> <K_UPDATE> <K_SET> { conflictAction = new InsertConflictAction( ConflictActionType.DO_UPDATE ); }
            updateSets = UpdateSets() { conflictAction.setUpdateSets(updateSets); }
            [ whereExpression = WhereClause() ]
        )
    )

    { return conflictAction
                .withWhereExpression(whereExpression); }
}

InsertDuplicateAction InsertDuplicateAction():
{
    InsertDuplicateAction duplicateAction;
    Expression whereExpression = null;
    List<UpdateSet> updateSets;
}
{
    (
        LOOKAHEAD(2) (
            <K_NOTHING> { duplicateAction = new InsertDuplicateAction( ConflictActionType.NOTHING ); }
        )
        |
        (
            { duplicateAction = new InsertDuplicateAction( ConflictActionType.DO_UPDATE ); }
            updateSets = UpdateSets() { duplicateAction.setUpdateSets(updateSets); }
            [ whereExpression = WhereClause() ]
        )
    )

    { return duplicateAction
                .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;
    ExpressionList<Column> columns;
    List<UpdateSet> updateSets;

    Select select = null;
    List<UpdateSet> duplicateUpdateSets;
    InsertDuplicateAction duplicateAction = null;
    Token tk = null;
}
{
    (
        <K_UPSERT> { upsert.setUpsertType(UpsertType.UPSERT); }
        |
        <K_REPLACE> { upsert.setUpsertType(UpsertType.REPLACE); }
        |
        (
            <K_INSERT> <K_OR> <K_REPLACE> { upsert.setUpsertType(UpsertType.INSERT_OR_REPLACE); }
        )
    )
    [ LOOKAHEAD(2) <K_INTO> { upsert.setUsingInto(true); } ]

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

    [ LOOKAHEAD(2) columns = ParenthesedColumnList() { upsert.setColumns(columns); } ]
    (
        (
            <K_SET>
            updateSets = UpdateSets() { upsert.setUpdateSets(updateSets); }
        )
        |
        (
            select = Select() { upsert.setSelect(select); }
        )
    )

    [
        <K_ON> <K_DUPLICATE> <K_KEY> <K_UPDATE>
        duplicateAction = InsertDuplicateAction() { upsert.setDuplicateAction(duplicateAction); }
    ]

    {
        return upsert;
    }
}

Delete DeleteWithWithItems( List<WithItem<?>> withItems ):
{
    Delete delete;
}
{
    delete = Delete() { delete.setWithItemsList( withItems );
    return delete;
}
}

Delete Delete():
{
    Delete delete = new Delete();
    Table table = null;
    List<Table> tables = new ArrayList<Table>();
    List<WithItem<?>> with = null;
    FromItem usingFromItem = null;
    List<FromItem> usingFromItemList = new ArrayList<FromItem>();
    List<Join> joins = null;
    Expression where = null;
    PreferringClause preferringClause = null;
    Limit limit = null;
    OptionClause optionClause = null;
    List<OrderByElement> orderByElements;
    boolean hasFrom = false;
    Token tk = null;
    DeleteModifierPriority modifierPriority = null;
    boolean modifierIgnore = false;
    boolean modifierQuick = false;

    ReturningClause returningClause;
    OutputClause outputClause;
}
{
    <K_DELETE> { delete.setOracleHint(getOracleHint()); }
    [ LOOKAHEAD(2) <K_LOW_PRIORITY> { modifierPriority = DeleteModifierPriority.LOW_PRIORITY; }]
    [ LOOKAHEAD(2) <K_QUICK> { modifierQuick = true; }]
    [ LOOKAHEAD(2) <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() [ LOOKAHEAD(2)  joins=JoinsList() ] ]
    [ <K_USING> usingFromItem=FromItem() { usingFromItemList.add(usingFromItem); }
          ("," usingFromItem=FromItem() { usingFromItemList.add(usingFromItem); } )*]
    [where=WhereClause() { delete.setWhere(where); } ]
    [preferringClause=PreferringClause() { delete.setPreferringClause(preferringClause);} ]
    [orderByElements = OrderByElements() { delete.setOrderByElements(orderByElements); } ]
    [limit=PlainLimit() {delete.setLimit(limit); } ]
    [ LOOKAHEAD(2) optionClause = OptionClause() { delete.setOption(optionClause); } ]

    [ returningClause = ReturningClause() { delete.setReturningClause(returningClause); } ]
    {
        if (joins != null && joins.size() > 0) {
            delete.setJoins(joins);
        }
        return delete.withWithItemsList(with)
              .withTables(tables)
              .withTable(table)
              .withHasFrom(hasFrom)
              .withUsingFromItemList(usingFromItemList)
              .withModifierPriority(modifierPriority)
              .withModifierIgnore(modifierIgnore)
              .withModifierQuick(modifierQuick);
    }
}

Statement Merge( List<WithItem<?>> with ) : {
    Merge merge = new Merge();
    Table table;
    FromItem fromItem;
    Expression condition;
    List<MergeOperation> operations;
    OutputClause outputClause;
    OptionClause optionClause = null;
}
{
    <K_MERGE> { merge.setOracleHint(getOracleHint()); } <K_INTO> table=TableWithAlias() { merge.setTable(table); }
    <K_USING> fromItem = FromItem() { merge.setFromItem(fromItem); }
    <K_ON> condition = Expression() { merge.setOnCondition(condition); }

    operations = MergeOperations() { merge.setOperations(operations); }

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

    [ LOOKAHEAD(2) optionClause = OptionClause() { merge.setOption(optionClause); } ]

    { return merge.withWithItemsList(with); }
}

List<MergeOperation> MergeOperations() : {
    List<MergeOperation> operationsList = new ArrayList<MergeOperation>();
    MergeOperation operation;
}
{
    (
        LOOKAHEAD(2) operation = MergeWhenMatched() { operationsList.add(operation); }
        |
        operation = MergeWhenNotMatched() { operationsList.add(operation); }
    )*
    { return operationsList; }
}

MergeOperation MergeWhenMatched() : {
    Expression predicate = null;
    MergeOperation operation;
}
{
    <K_WHEN> <K_MATCHED>
    [ <K_AND> predicate = Expression() ]
    <K_THEN>
    (
        operation = MergeDeleteClause(predicate) | operation = MergeUpdateClause(predicate)
    )
    { return operation; }
}

MergeOperation MergeDeleteClause(Expression predicate) : {
    MergeDelete md = new MergeDelete().withAndPredicate(predicate);
}
{
    <K_DELETE> { return md; }
}

MergeOperation MergeUpdateClause(Expression predicate) : {
    MergeUpdate mu = new MergeUpdate().withAndPredicate(predicate);
    List<UpdateSet> updateSets;
    Expression condition;
}
{
    <K_UPDATE> <K_SET> updateSets = UpdateSets() { mu.setUpdateSets(updateSets); }
    [ <K_WHERE> condition = Expression() { mu.setWhereCondition(condition); }]
    [ LOOKAHEAD(2)  <K_DELETE> <K_WHERE> condition = Expression() { mu.setDeleteWhereCondition(condition); } ]
    { return mu; }
}

MergeInsert MergeInsertClause(Expression predicate) : {
    MergeInsert mi = new MergeInsert();
    ExpressionList<Column> columns;
    ExpressionList expList;
    Expression condition;
}
{
    <K_INSERT>
    [ "(" columns = ColumnList() ")"
        {
            mi.setColumns( new ParenthesedExpressionList<Column>(columns) );
        }
    ]
    <K_VALUES> "(" expList = SimpleExpressionList() ")"
    {
        mi.setValues( new ParenthesedExpressionList(expList) );
    }

    [ <K_WHERE> condition = Expression() { mi.setWhereCondition(condition); } ]

    {
        mi.setAndPredicate(predicate);
        return mi;
    }
}

MergeOperation MergeWhenNotMatched() : {
    MergeOperation operation;
    Expression predicate = null;
    MergeSide side = null;
    Token sideToken;
}
{
    <K_WHEN> <K_NOT> <K_MATCHED>
    [ <K_BY> sideToken = <S_IDENTIFIER> {
        side = MergeSide.fromImage(sideToken.image);
    } ]
    [ <K_AND> predicate = Expression() ]
    <K_THEN>
    (
        operation = MergeInsertClause(predicate) { ((MergeInsert) operation).setSide(side); }
        |
        operation = MergeUpdateClause(predicate) { ((MergeUpdate) operation).setSide(side); }
        |
        operation = MergeDeleteClause(predicate) { ((MergeDelete) operation).setSide(side); }
    )
    { return MergeSide.validatePairing(side, operation); }
}

// table names seem to allow ":" delimiters, e.g. for Informix see #1134
ObjectNames RelObjectNames() : {
    String token = null;
    Token delimiter = null;
    List<String> data = new ArrayList<String>();
    List<String> delimiters = new ArrayList<String>();
} {
    token = RelObjectName() { data.add(token); }
    (
        LOOKAHEAD (2) (
            ( delimiter = "..."  { delimiters.add("."); data.add(null); delimiters.add("."); data.add(null); delimiters.add("."); } )
            |
            ( delimiter = ".."  { delimiters.add("."); data.add(null); delimiters.add("."); } )
            |
            ( ( delimiter = "." | delimiter = ":" ) { delimiters.add(delimiter.image); } )
        )

        token = RelObjectNameExt() { data.add(token); }
    ) *

    { return new ObjectNames(data, delimiters); }
}

// column names do not allow ":" delimeters as those represent JSON `GET` operators
ObjectNames ColumnIdentifier() : {
    String token = null;
    Token delimiter = null;
    List<String> data = new ArrayList<String>();
    List<String> delimiters = new ArrayList<String>();
} {
    token = RelObjectName() { data.add(token); }
    (
        LOOKAHEAD (2) (
            ( delimiter = "..."  { delimiters.add("."); data.add(null); delimiters.add("."); data.add(null); delimiters.add("."); } )
            |
            ( delimiter = ".."  { delimiters.add("."); data.add(null); delimiters.add("."); } )
            |
            ( delimiter = "."  { delimiters.add(delimiter.image); } )
        )

        token = RelObjectNameExt() { data.add(token); }
    ) *

    { return new ObjectNames(data, delimiters); }
}

// See: http://technet.microsoft.com/en-us/library/ms187879%28v=sql.105%29.aspx
Column Column() #Column :
{
    ObjectNames data = null;
    ArrayConstructor arrayConstructor = null;
    Token tk = null;
}
{
    data = ColumnIdentifier()
    [ LOOKAHEAD(2) <K_COMMENT> tk=<S_CHAR_LITERAL> ]
    // @todo: we better should return a SEQUENCE instead of a COLUMN
    [  LOOKAHEAD(2) "." <K_NEXTVAL> { data.getNames().add("nextval"); } ]

    [ LOOKAHEAD(2) arrayConstructor = ArrayConstructor(false) ]
    {
        Column col = new Column(data.getNames(), data.getDelimiters());
        if (tk != null) { col.withCommentText(tk.image); }
        if (arrayConstructor!=null) {
            col.setArrayConstructor(arrayConstructor);
        }
        linkAST(col,jjtThis);
        return col;
    }
}

/*
 * Unified identifier production for SQL object names.
 *
 * Accepts base identifier tokens (S_IDENTIFIER, S_QUOTED_IDENTIFIER, DATA_TYPE,
 * date literals), any non-reserved keyword, and — guarded by the semantic
 * check isReservedKeywordAsIdentifier() — reserved keywords that can serve as
 * unquoted identifiers in the current parser position.
 *
 * NOTE: K_FROM, K_SELECT, and K_CURRENT are deliberately NOT included here
 * to avoid FIRST-set pollution in JavaCC's choice resolution.  They are only
 * valid as identifiers in dotted-name continuations (after '.'), named
 * parameters (after ':'), index columns, constraint names, and similar
 * restricted contexts.  Those call sites add the three tokens inline.
 */
String RelObjectName() :
{    Token tk = null; String result = null; }
{
    (
      /* ── Base identifier tokens ─────────────────────────────────────── */
      tk=<DATA_TYPE>
      | tk=<S_IDENTIFIER>
      | tk=<S_QUOTED_IDENTIFIER>
      | tk=<K_DATETIMELITERAL>
      | tk=<K_DATE_LITERAL>

      /* ── Non-reserved keywords (range-guarded) ──────────────────────── */
      | LOOKAHEAD({ getToken(1).kind >= MIN_NON_RESERVED_WORD
                        && getToken(1).kind <= MAX_NON_RESERVED_WORD })
        result = NonReservedWord()

      /* ── Reserved keywords usable as identifiers (context-guarded) ─── */
      | LOOKAHEAD({ isReservedKeywordAsIdentifier() })
        ( tk=<K_ALL> | tk=<K_ANY> | tk=<K_CASEWHEN> | tk=<K_CONNECT>
          | tk=<K_CREATE> | tk=<K_DEFAULT>
          | tk=<K_GLOBAL> | tk=<K_GROUP> | tk=<K_GROUPING> | tk=<K_IF>
          | tk=<K_IIF> | tk=<K_IGNORE> | tk=<K_IN> | tk=<K_INTERVAL>
          | tk=<K_LEFT> | tk=<K_LIMIT> | tk=<K_NEXTVAL> | tk=<K_OFFSET>
          | tk=<K_ON> | tk=<K_OPTIMIZE> | tk=<K_ORDER> | tk=<K_PROCEDURE>
          | tk=<K_PUBLIC> | tk=<K_QUALIFY> | tk=<K_RIGHT>
          | tk=<K_SET> | tk=<K_SOME> | tk=<K_START> | tk=<K_TABLES>
          | tk=<K_TOP> | tk=<K_VALUE> | tk=<K_VALUES> )
    )
    { return result != null ? result : tk.image; }
}

/*
 * Extended version of RelObjectName that additionally accepts FROM, SELECT,
 * and CURRENT as unquoted identifiers.
 *
 * These three tokens are kept OUT of RelObjectName() to avoid polluting
 * JavaCC's FIRST-set computation (which would cause choice conflicts in
 * expression parsing, subselect detection, etc.).
 *
 * Used only in specific contexts where the old grammar's RelObjectNameExt2
 * was called: dotted-name continuations, index/constraint names, type names,
 * named-parameter identifier chains, and join table references.
 */
String RelObjectNameExt() :
{ Token tk = null; String result = null; }
{
    ( result = RelObjectName() | tk=<K_FROM> | tk=<K_SELECT> | tk=<K_CURRENT> )
    { return tk != null ? tk.image : result; }
}

Table Table() #TableName :
{
    //String serverName = null, databaseName = null, schemaName = null, tableName = null;
    ObjectNames data = null;
    Token fileNameToken = null;
    Table table;
    String timeTravelStr = null;
}
{
    (
        data = RelObjectNames() [ LOOKAHEAD(2) timeTravelStr = TimeTravelBeforeAlias() ]
        {
            table = new Table(data.getNames());
            table.setTimeTravel(timeTravelStr);
        }
        |
        fileNameToken = <S_CHAR_LITERAL>
        {
            // don't split name parts
            table = new Table(fileNameToken.image, false);
        }
    )

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

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

Table TableWithAliasAndMysqlIndexHint():
{
    Table table = null;
    Alias alias = null;
    MySQLIndexHint indexHint = null;
}
{
    table=Table()
    [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { table.setAlias(alias); } ]
    [ LOOKAHEAD(2) indexHint=MySQLIndexHint() { table.setHint(indexHint); } ]
    { return table; }
}

Number Number():
{
    Token token;
    Number number;
}
{
    (
        token = <S_DOUBLE> { number = Double.valueOf(token.image); }
        |
        token = <S_LONG> { number = Long.valueOf(token.image); }
    )

    {
        return number;
    }
}

SampleClause SampleClause():
{
    Token token;
    SampleClause sampleClause;
    String keyword;
    String method=null;
    Number percentageArgument;
    String percentageUnit = null;
    boolean argumentInBrackets = true;
    Number offsetArgument = null;
    Number repeatArgument=null;
    Number seedArgument=null;
}
{
    (
        (
            // Oracle
            token=<K_SAMPLE> { keyword = token.image; }
            [ token=<K_BLOCK> { method = token.image; } ]
        )
        |
        (
            // SQL:2016 compliant
            token = <K_TABLESAMPLE> { keyword = token.image; }
            ( token = <K_SYSTEM> | token = <K_BERNOULLI> ) { method = token.image; }
        )
        |
        (
            // Duck DB
            <K_USING> <K_SAMPLE> { keyword = "USING SAMPLE"; }
            ( token = <K_SYSTEM> | token = <K_BERNOULLI> ) { method = token.image; }
        )
    )

    (
        "(" percentageArgument = Number()
        [
            "%" { percentageUnit="%"; }
            |
            <K_PERCENT> { percentageUnit="PERCENT"; }
            |
            <K_ROWS> { percentageUnit="ROWS"; }
        ]
        ")"

        [ LOOKAHEAD(2) <K_REPEATABLE> "(" repeatArgument = Number() ")" ]

        [ LOOKAHEAD(2) <K_SEED> "(" seedArgument = Number() ")" ]
        |
        percentageArgument = Number() { argumentInBrackets = false; }
        [ LOOKAHEAD(2) <K_OFFSET> offsetArgument = Number() ]
    )

    {
        sampleClause = new SampleClause(keyword, method, percentageArgument, percentageUnit, repeatArgument, seedArgument);
        sampleClause.setArgumentInBrackets(argumentInBrackets);
        sampleClause.setOffsetArgument(offsetArgument);
        return sampleClause;
    }
}

Select SelectWithWithItems( List<WithItem<?>> withItems):
{
    Select select;
}
{
    select = Select() { select.setWithItemsList( withItems );
    return select;
}
}

Select Select() #Select:
{
    Select select = null;
    List<WithItem<?>> with = null;
    List<OrderByElement> orderByElements = null;
    List<InterpolateElement> interpolateElements = null;
    OptionClause optionClause = null;
    Limit limit = null;
    Offset offset = null;
    Fetch fetch = null;
    WithIsolation withIsolation = null;
    Alias alias = null;
}
{
    [ with=WithList() ]
    (
        LOOKAHEAD(3) select = FromQuery()
        |
        (
            (
                LOOKAHEAD(3) select = PlainSelect()
                |
                LOOKAHEAD(3) select = Values()
                |
                LOOKAHEAD(3) select = ParenthesedSelect() [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() {select.setAlias(alias);} ]
            )
            [ LOOKAHEAD(2) select = FromQueryFromSelect(select) ]
            [ LOOKAHEAD(2) select = SetOperationList(select) ]

            [ LOOKAHEAD(<K_ORDER> <K_BY>) orderByElements = OrderByElements() { select.setOrderByElements(orderByElements); } ]
            [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { select.setInterpolate(interpolateElements); } ]
            [ LOOKAHEAD(2, { !(select instanceof Values) }) optionClause = OptionClause() { select.setOption(optionClause); } ]

            [ LOOKAHEAD(<K_LIMIT>) limit=LimitWithOffset() {select.setLimit(limit);} ]
            [ LOOKAHEAD(<K_OFFSET>) offset = Offset() { select.setOffset(offset);} ]
            [ LOOKAHEAD(<K_FETCH>) fetch = Fetch() { select.setFetch(fetch);} ]
            [ LOOKAHEAD(<K_WITH> <K_ISOLATION>) withIsolation = WithIsolation() { select.setIsolation(withIsolation);} ]
        )
    )
    {
        linkAST(select, jjtThis);
        return select.withWithItemsList(with);
    }
}

FromQuery FromQuery() #FromQuery:
{
    FromQuery fromQuery;
    FromItem fromItem;
    List<LateralView> lateralViews = null;
    List<Join> joins = null;
    PipeOperator pipeOperator;
}
{
    <K_FROM> fromItem = FromItem() { fromQuery = new FromQuery(fromItem); }
    [ LOOKAHEAD(2) lateralViews=LateralViews() { fromQuery.setLateralViews(lateralViews); } ]
    [ LOOKAHEAD(2) joins=JoinsList() { fromQuery.setJoins(joins); } ]
    (
        LOOKAHEAD(2) "|>" pipeOperator = PipeOperator() { fromQuery.add(pipeOperator); }
    )*

    {
        return fromQuery;
    }
}

FromQuery FromQueryFromSelect(Select select):
{
    FromQuery fromQuery;
    FromItem fromItem;
    PipeOperator pipeOperator;
}
{
    "|>" pipeOperator = PipeOperator()
    {
        fromQuery = new FromQuery(select, false);
        fromQuery.add(pipeOperator);
    }
    (
        LOOKAHEAD(2) "|>" pipeOperator = PipeOperator()
        { fromQuery.add(pipeOperator); }
    )*

    {
        return fromQuery;
    }
}

PipeOperator PipeOperator() #PipeOperator:
{
    PipeOperator operator;
}
{
    (
        // SELECT covers also EXTEND, WINDOW and RENAME
        operator = SelectPipeOperator()
        |
        operator = SetPipeOperator()
        |
        operator = DropPipeOperator()
        |
        LOOKAHEAD(2) operator = AsPipeOperator()
        |
        operator = WherePipeOperator()
        |
        operator = LimitPipeOperator()
        |
        LOOKAHEAD(2) operator = AggregatePipeOperator()
        |
        operator = OrderByPipeOperator()
        |
        // covers UNION, INTERSET, EXCEPT
        operator = SetOperationPipeOperator()
        |
        operator = JoinPipeOperator()
        |
        operator = CallPipeOperator()
        |
        operator = TableSamplePipeOperator()
        |
        operator = PivotPipeOperator()
        |
        operator = UnPivotPipeOperator()
    )
    {
        return operator;
    }
}

SelectPipeOperator SelectPipeOperator():
{
    Token operatorKeyToken;
    Token modifierToken = null;
    SelectPipeOperator selectPipeOperator;
    SelectItem<?> selectItem;
}
{
    (
        ( operatorKeyToken = <K_SELECT> [ LOOKAHEAD(2) ( modifierToken=<K_DISTINCT> | modifierToken=<K_ALL> ) ] )
        |
        operatorKeyToken = <K_EXTEND>
        |
        operatorKeyToken = <K_WINDOW>
        |
        operatorKeyToken = <K_RENAME>
    )
    selectItem = SelectItem()
    { selectPipeOperator = new SelectPipeOperator(operatorKeyToken.image, selectItem, modifierToken !=null ? modifierToken.image : null); }

    ( LOOKAHEAD(2) "," selectItem = SelectItem() { selectPipeOperator.add(selectItem); } )*

    {
        return selectPipeOperator;
    }
}

WherePipeOperator WherePipeOperator():
{
    WherePipeOperator wherePipeOperator;
    Expression expression;
}
{
    <K_WHERE> expression = Expression()
    {
        wherePipeOperator = new WherePipeOperator(expression);
        return wherePipeOperator;
    }
}

String OrderSuffix():
{
    Token token =null;
    String orderSuffix = null;
}
{
    ( token = <K_ASC> | token = <K_DESC> ) { orderSuffix = token.image; }
    [ LOOKAHEAD(2) <K_NULLS> ( token = <K_FIRST> | token = <K_LAST> ) { orderSuffix += " NULLS " + token.image; } ]

    {
        return orderSuffix;
    }
}

AggregatePipeOperator AggregatePipeOperator():
{
    AggregatePipeOperator aggregatePipeOperator;
    SelectItem<?> selectItem;
    Token token =null;
    String orderSuffix = null;
}
{
    <K_AGGREGATE>
    selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ]
    { aggregatePipeOperator = new AggregatePipeOperator(selectItem, orderSuffix); orderSuffix=null; }

    ( LOOKAHEAD(2) "," selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ]
    { aggregatePipeOperator.add(selectItem, orderSuffix); orderSuffix=null; } )*

    [
        LOOKAHEAD(2) <K_GROUP> [ <K_AND> <K_ORDER> { aggregatePipeOperator.setShorthandOrdering(true); } ] <K_BY>
        selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ]
        { aggregatePipeOperator.addGroupItem(selectItem, orderSuffix); orderSuffix=null; }

        (
            LOOKAHEAD(2) "," selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ]
            { aggregatePipeOperator.addGroupItem(selectItem, orderSuffix); orderSuffix=null; }
        )*
    ]

    {
        return aggregatePipeOperator;
    }
}

OrderByPipeOperator OrderByPipeOperator():
{
    OrderByPipeOperator orderByPipeOperator;
    List<OrderByElement> orderByElements;
}
{
    orderByElements = OrderByElements()
    {
        orderByPipeOperator = new OrderByPipeOperator(orderByElements);
        return orderByPipeOperator;
    }
}

AsPipeOperator AsPipeOperator():
{
    AsPipeOperator asPipeOperator;
    Alias alias;
}
{
    <K_AS> alias = Alias()
    {
        asPipeOperator = new AsPipeOperator( alias.withUseAs(true) );
        return asPipeOperator;
    }
}

JoinPipeOperator JoinPipeOperator():
{
    JoinPipeOperator joinPipeOperator;
    Join join;
}
{
    join = JoinerExpression()
    {
        joinPipeOperator = new JoinPipeOperator(join);
        return joinPipeOperator;
    }
}

SetPipeOperator SetPipeOperator():
{
    SetPipeOperator setPipeOperator;
    List<UpdateSet> updateSets;
}
{
    <K_SET> updateSets = UpdateSets()
    {
        setPipeOperator = new SetPipeOperator(updateSets);
        return setPipeOperator;
    }
}

DropPipeOperator DropPipeOperator():
{
    DropPipeOperator dropPipeOperator;
    ExpressionList<Column> columns;
}
{
    <K_DROP> columns = ColumnList()
    {
        dropPipeOperator = new DropPipeOperator(columns);
        return dropPipeOperator;
    }
}

LimitPipeOperator LimitPipeOperator():
{
    LimitPipeOperator limitPipeOperator;
    Expression expression;
}
{
    <K_LIMIT> expression = Expression() { limitPipeOperator = new LimitPipeOperator(expression); }
    [ LOOKAHEAD(2) <K_OFFSET> expression = Expression() { limitPipeOperator.setOffsetExpression(expression); } ]

    {
        return limitPipeOperator;
    }
}

// see https://manticore-projects.com/SQL2016Parser/syntax_snapshot.html#corresponding-spec
String SetOperationModifier():
{
    Token tk;
    String modifier = "";
    String identifier;
}
{
    (
        LOOKAHEAD(2) (
             [ ( tk=<K_ALL> | tk="DISTINCT")  { modifier+=tk.image; } ]
            <K_BY> <K_NAME> { modifier+= " BY NAME"; }
            [
                "MATCHING" { modifier+= " MATCHING"; }
                "("
                identifier = RelObjectName() { modifier+="(" + identifier; }
                ("," identifier = RelObjectName()  { modifier+=", " + identifier; })*
                ")" { modifier+=")"; }
            ]
        )
        |
        (
            [ <K_STRICT>  { modifier+= " STRICT"; } ]
            <K_CORRESPONDING> { modifier+= " CORRESPONDING"; }
            [ (tk=<K_ALL> | tk="DISTINCT")  { modifier+=tk.image; } ]
            [
                <K_BY> { modifier+= " BY"; }[ (tk=<K_ALL> | tk="DISTINCT")  { modifier+=tk.image; } ]
                "("
                identifier = RelObjectName() { modifier+="(" + identifier; }
                ("," identifier = RelObjectName()  { modifier+=", " + identifier;})*
                ")" { modifier+=")"; }
            ]
        )
        |
        ( tk=<K_ALL> | tk=<K_DISTINCT> ) { modifier+=tk.image; }
    )
    {
        return modifier;
    }
}

SetOperationPipeOperator SetOperationPipeOperator():
{
    SetOperationPipeOperator setOperationPipeOperator = null;
    SetOperationType setOperationType;
    String modifier = null;
    ParenthesedSelect select;
}
{
    (
        (
            <K_UNION>  [ modifier=SetOperationModifier() ] { setOperationType = SetOperationType.UNION; }
            select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType,  modifier); }
        )
        |
        (
            <K_INTERSECT> [ modifier=SetOperationModifier() ]  { setOperationType = SetOperationType.INTERSECT; }
            select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType,  modifier); }
        )
        |
        (
            <K_EXCEPT> [ modifier=SetOperationModifier() ]  { setOperationType = SetOperationType.EXCEPT; }
            select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType,  modifier); }
        )
    )

    (
        LOOKAHEAD(2) "," select = ParenthesedSelect() { setOperationPipeOperator.add(select); }
    )*

    {
        return setOperationPipeOperator;
    }
}

CallPipeOperator CallPipeOperator():
{
    TableFunction tableFunction;
    Alias alias=null;
}
{
    <K_CALL> tableFunction = TableFunction() [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ]

    {
        return new CallPipeOperator(tableFunction, alias);
    }
}


TableSamplePipeOperator TableSamplePipeOperator():
{
    Token token;
}
{
    <K_TABLESAMPLE> <K_SYSTEM> "(" ( token=<S_DOUBLE> | token=<S_LONG> ) <K_PERCENT> ")"
    {
        return new TableSamplePipeOperator( token.image );
    }
}

PivotPipeOperator PivotPipeOperator():
{
    Function aggregateExpression;
    Column inputColumn;
    List<SelectItem<?>> pivotColumns;
    Alias alias = null;
}
{
    <K_PIVOT> "(" aggregateExpression=Function()
    <K_FOR> inputColumn=Column()
    <K_IN> "(" pivotColumns = SelectItemsList() ")"
    ")"
    [ LOOKAHEAD({ isAliasAhead() })  alias = Alias() ]
    {
        return new PivotPipeOperator(aggregateExpression, inputColumn, pivotColumns, alias);
    }
}

UnPivotPipeOperator UnPivotPipeOperator():
{
    Column valuesColumn;
    Column nameColumn;
    List<SelectItem<?>> pivotColumns;
    Alias alias = null;
}
{
    <K_UNPIVOT> "(" valuesColumn=Column()
    <K_FOR> nameColumn=Column()
    <K_IN> "(" pivotColumns = SelectItemsList() ")"
    ")"
    [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ]
    {
        return new UnPivotPipeOperator(valuesColumn, nameColumn, pivotColumns, alias);
    }
}

TableStatement TableStatement():
{
    Table table = null;
    List<OrderByElement> orderByElements = null;
    Limit limit = null;
    Offset offset = null;
    TableStatement tableStatement = new TableStatement();
}{
    <K_TABLE>
    table = Table()
    { tableStatement.setTable(table); }
    [ LOOKAHEAD(<K_ORDER> <K_BY>) orderByElements = OrderByElements() { tableStatement.setOrderByElements(orderByElements); } ]
    [ LOOKAHEAD(<K_LIMIT>) limit = LimitWithOffset() { tableStatement.setLimit(limit);} ]
    [ LOOKAHEAD(<K_OFFSET>) offset = Offset() { tableStatement.setOffset(offset);} ]
    { return tableStatement; }
    /* Support operationList */
}

ParenthesedSelect ParenthesedSelect() #ParenthesedSelect:
{
    ParenthesedSelect parenthesedSelect = new ParenthesedSelect();
    Select select;
}
{
    "("
    select = Select()
    ")"
    {
        linkAST(parenthesedSelect,jjtThis);
        return parenthesedSelect.withSelect(select);
    }
}

ParenthesedInsert ParenthesedInsert() #ParenthesedInsert:
{
    ParenthesedInsert parenthesedInsert = new ParenthesedInsert();
    Insert insert;
}
{
    "("
    insert = Insert()
    ")"
    {
        return parenthesedInsert.withInsert(insert);
    }
}

ParenthesedUpdate ParenthesedUpdate() #ParenthesedUpdate:
{
    ParenthesedUpdate parenthesedUpdate = new ParenthesedUpdate();
    Update update;
}
{
    "("
    update = Update()
    ")"
    {
        return parenthesedUpdate.withUpdate(update);
    }
}

ParenthesedDelete ParenthesedDelete() #ParenthesedDelete:
{
    ParenthesedDelete parenthesedDelete = new ParenthesedDelete();
    Delete delete;
}
{
    "("
    delete = Delete()
    ")"
    {
        return parenthesedDelete.withDelete(delete);
    }
}

LateralView LateralView() #LateralView:
{
    boolean useOuter = false;
    Function generatorFunction = null;
    String tableName = null;
    String columnName = null;
    Alias tableAlias = null;
    Alias columnAlias = null;
}
{
    <K_LATERAL> <K_VIEW> [ <K_OUTER> { useOuter=true; } ]
    generatorFunction = Function()
    [ LOOKAHEAD(2)
        tableName=RelObjectName()
        {
            tableAlias = new Alias(tableName, false);
        }
    ]
    <K_AS> columnName = RelObjectName() { columnAlias = new Alias(columnName, true); }

    // Spark SQL supports multiple Alias Columns: https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select-lateral-view.html
    // we simulate this by setting the alias name to null and then just adding the columns
    [
        LOOKAHEAD(2) ","  { columnAlias.setName(null);  columnAlias.addAliasColumns( columnName); }
        columnName = RelObjectName() { columnAlias.addAliasColumns( columnName); }
        (
            LOOKAHEAD(2) "," columnName = RelObjectName() { columnAlias.addAliasColumns( columnName); }
        )*
    ]
    {
        return new LateralView(
            useOuter
            , generatorFunction
            , tableAlias
            , columnAlias
        );
    }
}

ForClause ForClause() #ForClause:
{
    Token token = null;
    ForClause forClause = new ForClause();
}
{
    <K_FOR>
    (
        token = <K_BROWSE>
        |
        token = <K_XML>
        (
            (
                ( <K_RAW> [ LOOKAHEAD(2) "(" <S_CHAR_LITERAL> ")" ] | <K_AUTO> )
                (
                    LOOKAHEAD(2) ","
                    (
                        <K_BINARY> <K_BASE64>
                        | <K_TYPE>
                        | <K_ROOT> [ LOOKAHEAD(2) "(" <S_CHAR_LITERAL> ")" ]
                        | <K_XMLDATA>
                        | <K_XMLSCHEMA> [ LOOKAHEAD(2) "(" <S_CHAR_LITERAL> ")"  ]
                        | <K_ELEMENTS> [ LOOKAHEAD(2) ( <K_XSINIL> | <K_ABSENT> ) ]
                    )
                )*
            )
            |
            (
                <K_EXPLICIT>
                (
                    LOOKAHEAD(2) ","
                    (
                        <K_BINARY> <K_BASE64>
                        | <K_TYPE>
                        | <K_ROOT> [ LOOKAHEAD(2) "(" <S_CHAR_LITERAL> ")" ]
                        | <K_XMLDATA>
                    )
                )*
            )
            |
            (
                <K_PATH> [ LOOKAHEAD(2) "(" <S_CHAR_LITERAL> ")" ]
                (
                    LOOKAHEAD(2) ","
                    (
                        <K_BINARY> <K_BASE64>
                        | <K_TYPE>
                        | <K_ROOT> [ LOOKAHEAD(2) "(" <S_CHAR_LITERAL> ")" ]
                        | <K_ELEMENTS> [ LOOKAHEAD(2) ( <K_XSINIL> | <K_ABSENT> ) ]
                    )
                )*
            )
        )
        |
        (
            token = <K_JSON> ( <K_AUTO> | <K_PATH> )
            (
                LOOKAHEAD(2) ","
                (
                    <K_ROOT> [ LOOKAHEAD(2) "(" <S_CHAR_LITERAL> ")" ]
                    | <K_INCLUDE_NULL_VALUES>
                    | <K_WITHOUT_ARRAY_WRAPPER>
                )
            )*
        )
    )
    {
        forClause.setForOption(token.image);
        linkAST(forClause,jjtThis);
        return forClause;
    }
}


List<LateralView> LateralViews():
{
    ArrayList<LateralView> lateralViews = new ArrayList<LateralView>();
    LateralView lateralView = null;
}
{
    lateralView = LateralView() { lateralViews.add(lateralView); }
    ( LOOKAHEAD(2) lateralView = LateralView() { lateralViews.add(lateralView); } )*

    {
        return lateralViews;
    }
}

LateralSubSelect LateralSubSelect() #LateralSubSelect:
{
    LateralSubSelect lateralSubSelect = new LateralSubSelect();;
    Select select;
}
{
    <K_LATERAL> "(" select = Select()  ")" { lateralSubSelect.withSelect(select).setPrefix("LATERAL"); }
    {
        linkAST(lateralSubSelect,jjtThis);
        return lateralSubSelect;
    }
}

PlainSelect PlainSelect() #PlainSelect:
{
    PlainSelect plainSelect = new PlainSelect();
    List<SelectItem<?>> selectItems = null;
    FromItem fromItem = null;
    List<LateralView> lateralViews = null;
    List<Join> joins = null;
    List<SelectItem<?>> distinctOn = null;
    Expression preWhere = null;
    Expression where = null;
    ForClause forClause = null;
    OptionClause optionClause = null;
    List<OrderByElement> orderByElements;
    List<InterpolateElement> interpolateElements = null;
    GroupByElement groupBy = null;
    Expression having = null;
    Expression qualify;
    Limit limitBy = 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;
    PreferringClause preferringClause = null;
    ExpressionList expressionList = null;
    boolean partitionByBrackets = false;
    List<Table> intoTables = null;
    MySqlSelectIntoClause mySqlSelectIntoClause = null;
    MySqlProcedureAnalyse mySqlProcedureAnalyse = null;
    Table updateTable = null;
    List<Table> updateTables = new ArrayList<Table>();
    Wait wait = null;
    boolean mySqlSqlCalcFoundRows = false;
    Token token;
    KSQLWindow ksqlWindow = null;
    boolean noWait = false;
    String windowName = null;
    WindowDefinition winDef;
    Table intoTempTable = null;
    List<UpdateSet> settings = null;
    Distinct distinct;
}
{
    <K_SELECT>

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

    { plainSelect.setOracleHint(getOracleHint()); }

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

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

    // Redshift allows TOP before DISTINCT
    // https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_list.html
    // @Todo: reflect the order when de-parsing
    [ LOOKAHEAD(2) top = Top() { plainSelect.setTop(top);    } ]

    [ LOOKAHEAD(2)
        (
        <K_ALL>
        |
        (
            <K_DISTINCT> { distinct = new Distinct(); plainSelect.setDistinct(distinct); }
            [ LOOKAHEAD(2) "ON" "(" distinctOn=SelectItemsList() { plainSelect.getDistinct().setOnSelectItems(distinctOn); } ")" ]
        )
        |
        <K_DISTINCTROW> { distinct = new Distinct(); distinct.setUseDistinctRow(true); plainSelect.setDistinct(distinct); }
        |
        <K_UNIQUE> { 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); }
        )
    ]

    [
        <K_AS>
        (
            <K_STRUCT> { plainSelect.setBigQuerySelectQualifier( PlainSelect.BigQuerySelectQualifier.AS_STRUCT ); }
            |
            <K_VALUE> { plainSelect.setBigQuerySelectQualifier( PlainSelect.BigQuerySelectQualifier.AS_VALUE ); }
        )
    ]

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

    selectItems=SelectItemsList()

    [ LOOKAHEAD(<K_INTO> (<K_OUTFILE> | <K_DUMPFILE>))
        mySqlSelectIntoClause = MySqlSelectIntoClause(MySqlSelectIntoClause.Position.BEFORE_FROM)
        { plainSelect.setMySqlSelectIntoClause(mySqlSelectIntoClause); }
    ]
    [ LOOKAHEAD(<K_INTO>)
        intoTables = IntoClause() { plainSelect.setIntoTables(intoTables); }
    ]
    [ LOOKAHEAD(2) <K_FROM> fromItem=FromItem()
        [ LOOKAHEAD(2) lateralViews=LateralViews() ]
        [ LOOKAHEAD(2) joins=JoinsList() ]
    ]
    [ LOOKAHEAD(3) <K_FROM> <K_ONLY> { plainSelect.setUsingOnly(true); } fromItem=FromItem()
            [ LOOKAHEAD(2) lateralViews=LateralViews() ]
            [ LOOKAHEAD(2) joins=JoinsList() ]
    ]

    // Clickhouse FINAL as shown at https://clickhouse.com/docs/en/operations/settings/settings#final
    [ LOOKAHEAD(2) <K_FINAL> { plainSelect.setUsingFinal(true); } ]

    [ LOOKAHEAD(2) ksqlWindow=KSQLWindowClause() { plainSelect.setKsqlWindow(ksqlWindow); } ]
    [ LOOKAHEAD(2) preWhere=PreWhereClause() { plainSelect.setPreWhere(preWhere); }]
    [ LOOKAHEAD(2) where=WhereClause() { plainSelect.setWhere(where); }]
    [ LOOKAHEAD(2) oracleHierarchicalQueryClause=OracleHierarchicalQueryClause() { plainSelect.setOracleHierarchical(oracleHierarchicalQueryClause); } ]
    [ LOOKAHEAD(2) preferringClause=PreferringClause() { plainSelect.setPreferringClause(preferringClause); }
        [LOOKAHEAD(2) <K_PARTITION> <K_BY>
            (
                LOOKAHEAD(2) expressionList=ComplexExpressionList()
                |
                "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")"
            )
            {
                preferringClause.setPartitionExpressionList(expressionList, partitionByBrackets);
            }
        ]
    ]
    // Oracle supports "HAVING" before "GROUP BY", we will simply parse that but won't pay special attention to the order
    [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); }]
    [ LOOKAHEAD(2) groupBy=GroupByColumnReferences() { plainSelect.setGroupByElement(groupBy); }]
    [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); }]
    [ LOOKAHEAD(2) qualify=Qualify() {plainSelect.setQualify(qualify); }]
    [ LOOKAHEAD(<K_ORDER> <K_SIBLINGS> <K_BY>) orderByElements = OrderByElements() { plainSelect.setOracleSiblings(true); plainSelect.setOrderByElements(orderByElements);    }   ]
    [ LOOKAHEAD(2) <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); } ]
    [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { plainSelect.setInterpolate(interpolateElements); } ]
    [ LOOKAHEAD(2) forClause = ForClause() {plainSelect.setForClause(forClause);} ]
    [ LOOKAHEAD(2) optionClause = OptionClause() { plainSelect.setOption(optionClause); } ]
    [ LOOKAHEAD(2) <K_EMIT> <K_CHANGES> { plainSelect.setEmitChanges(true); } ]
    // Parse the LIMIT row count once (this accepts a parenthesized subquery too), then
    // optionally attach ClickHouse's `LIMIT ... BY ...`. Checking BY right after the limit
    // expression avoids a numeric LOOKAHEAD, which cannot see past a long parenthesized
    // subquery and would wrongly commit to LIMIT BY (issue #2359).
    [ LOOKAHEAD(<K_LIMIT>) limit = LimitWithOffset()
        [ LOOKAHEAD(<K_BY>) <K_BY> expressionList = ExpressionList() { limit.setByExpressions(expressionList); } ]
        {
            if (limit.getByExpressions() != null) {
                plainSelect.setLimitBy(limit);
            } else {
                plainSelect.setLimit(limit);
            }
        } ]
    [ LOOKAHEAD(<K_OFFSET>) offset = Offset() { plainSelect.setOffset(offset);    } ]
	[ LOOKAHEAD(<K_LIMIT>, { limit==null }) limit = LimitWithOffset() { plainSelect.setLimit(limit);    } ]
    [ LOOKAHEAD(<K_PROCEDURE> <K_ANALYSE>)
        mySqlProcedureAnalyse = MySqlProcedureAnalyse()
        { plainSelect.setMySqlProcedureAnalyse(mySqlProcedureAnalyse); }
    ]
    [ LOOKAHEAD(<K_FETCH>) fetch = Fetch() { plainSelect.setFetch(fetch);    } ]
    [ LOOKAHEAD(<K_WITH> <K_ISOLATION>) withIsolation = WithIsolation() { plainSelect.setIsolation(withIsolation); } ]
    [ LOOKAHEAD(2)
        <K_FOR>
            (
            <K_UPDATE> { plainSelect.setForMode(ForMode.UPDATE); }
            | <K_SHARE> { plainSelect.setForMode(ForMode.SHARE); }
            | (<K_NO> <K_KEY> <K_UPDATE> { plainSelect.setForMode(ForMode.NO_KEY_UPDATE); })
            | (<K_KEY> <K_SHARE> { plainSelect.setForMode(ForMode.KEY_SHARE); })
            | (<K_READ> <K_ONLY> { plainSelect.setForMode(ForMode.READ_ONLY); })
            | (<K_FETCH> <K_ONLY> { plainSelect.setForMode(ForMode.FETCH_ONLY); })
            )
        [ LOOKAHEAD(2) <K_OF>
            updateTable = Table() { updateTables.add(updateTable); }
            ( LOOKAHEAD(2) "," updateTable = Table() { updateTables.add(updateTable); } )*
            { plainSelect.setForUpdateTables(updateTables); }
        ]
        [ LOOKAHEAD(<K_WAIT>) wait = Wait() { plainSelect.setWait(wait); } ]
        [ LOOKAHEAD(2) (<K_NOWAIT> { plainSelect.setNoWait(true); }
               | <K_SKIP> <K_LOCKED> { plainSelect.setSkipLocked(true); }) ]
        [ LOOKAHEAD(<K_ORDER> <K_BY>) orderByElements = OrderByElements()
            { plainSelect.setOrderByElements(orderByElements); plainSelect.setForUpdateBeforeOrderBy(true); }
        ]
        [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { plainSelect.setInterpolate(interpolateElements); } ]
    ]
    [ LOOKAHEAD(<K_INTO> (<K_OUTFILE> | <K_DUMPFILE>))
        mySqlSelectIntoClause = MySqlSelectIntoClause(MySqlSelectIntoClause.Position.TRAILING)
        { plainSelect.setMySqlSelectIntoClause(mySqlSelectIntoClause); }
    ]
    [ LOOKAHEAD(2) <K_SETTINGS> settings = UpdateSets() { plainSelect.setSettings(settings); } ]
    [ LOOKAHEAD(<K_OPTIMIZE>) optimize = OptimizeFor() { plainSelect.setOptimizeFor(optimize); } ]
    [ LOOKAHEAD(3) <K_INTO> <K_TEMP> intoTempTable = Table() { plainSelect.setIntoTempTable(intoTempTable);} ]
    [ LOOKAHEAD(3)<K_WITH> <K_NO> <K_LOG> { plainSelect.setUseWithNoLog(true); } ]
    {
        plainSelect.setSelectItems(selectItems);
        plainSelect.setFromItem(fromItem);
        if ( lateralViews!=null && lateralViews.size()>0 ) {
            plainSelect.setLateralViews( lateralViews );
        }
        if ( joins!=null && joins.size()>0 ) {
            plainSelect.setJoins( joins );
        }
        linkAST(plainSelect,jjtThis);
        return plainSelect;
    }
}

Select SetOperationList(Select select) #SetOperationList: {
    SetOperationList list = new SetOperationList();
    List<OrderByElement> orderByElements = null;
    List<InterpolateElement> interpolateElements = null;
    Limit limit = null;
    Offset offset = null;
    Fetch fetch = null;
    WithIsolation withIsolation = null;
    List<Select> selects = new ArrayList<Select>();
    List<SetOperation> operations = new ArrayList<SetOperation>();
    String modifier = null;
}
{

    {
        selects.add(select);
    }

    ( LOOKAHEAD(2) { modifier = null; } (
            (
                <K_UNION> [ modifier=SetOperationModifier() ] { UnionOp union = new UnionOp(modifier); linkAST(union,jjtThis); operations.add(union); }

            )
            |
            (
                <K_INTERSECT> [ modifier=SetOperationModifier() ] { IntersectOp intersect = new IntersectOp(modifier); linkAST(intersect,jjtThis); operations.add(intersect); }
            )
            |
            (
                <K_MINUS> [ modifier=SetOperationModifier() ] { MinusOp minus = new MinusOp(modifier); linkAST(minus,jjtThis); operations.add(minus); }
            )
            |
            (
                <K_EXCEPT> [ modifier=SetOperationModifier() ] { ExceptOp except = new ExceptOp(modifier); linkAST(except,jjtThis); operations.add(except); }
            )

        )

        (
            select = PlainSelect()
            |
            select = Values()
            |
            select = ParenthesedSelect()
        )
        {
            selects.add(select);
        }
    )+

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

    {
        if ( selects.get(selects.size()-1) instanceof PlainSelect ) {
            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.getInterpolate() != null) {
                list.setInterpolate(ps.getInterpolate());
                ps.setInterpolate(null);
            }
            if (ps.getOption() != null) {
                list.setOption(ps.getOption());
                ps.setOption(null);
            }
            if (ps.getFetch() != null) {
                list.setFetch(ps.getFetch());
                ps.setFetch(null);
            }
            if (ps.getIsolation() != null) {
                list.setIsolation(ps.getIsolation());
                ps.setIsolation(null);
            }
        }
        list.setBracketsOpsAndSelects(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:
{
    boolean recursive = false;
    boolean materialized = false;
    boolean usingNot = false;
    String name = null;
    List<SelectItem<?>> selectItems = null;
    WithFunctionDeclaration withFunctionDeclaration = null;
    ParenthesedStatement statement = null;
    WithSearchClause withSearchClause = null;
    WithItem<?> withItem;
}
{
    (
         LOOKAHEAD(2) <K_FUNCTION>
         withFunctionDeclaration = WithFunctionDeclaration()
         {
             withItem = new WithItem().withWithFunctionDeclaration(withFunctionDeclaration);
         }
         |
         (
             [ LOOKAHEAD(2) <K_RECURSIVE>  { recursive = true; } ]
             name=RelObjectName()
             [ "(" selectItems=SelectItemsList() ")" ]
             <K_AS>
             [ LOOKAHEAD(2) [ <K_NOT> { usingNot = true; } ] <K_MATERIALIZED>  { materialized = true; } ]
             (
                 LOOKAHEAD(2) statement = ParenthesedSelect()
                 |
                 LOOKAHEAD(2) statement = ParenthesedInsert()
                 |
                 LOOKAHEAD(2) statement = ParenthesedUpdate()
                 |
                 LOOKAHEAD(2) statement = ParenthesedDelete()
             )
             {
                withItem = new WithItem(statement, new Alias(name, false))
                    .withRecursive(recursive, usingNot, materialized)
                    .withWithItemList(selectItems);
             }
         )
     )
     [ withSearchClause = WithSearchClause() { withItem.setSearchClause(withSearchClause); } ]
     {
     return withItem;
     }
}

WithSearchClause WithSearchClause() #WithSearchClause:
{
    Token orderingToken;
    ExpressionList<Column> searchColumns = new ExpressionList<Column>();
    Column searchColumn = null;
    String sequenceColumnName;
}
{
    <K_SEARCH>
    ( orderingToken=<K_BREADTH> | orderingToken=<K_DEPTH> )
    <K_FIRST>
    <K_BY>
    searchColumn = Column() { searchColumns.add(searchColumn); }
    ( "," searchColumn = Column() { searchColumns.add(searchColumn); } )*
    <K_SET>
    sequenceColumnName = RelObjectName()
    {
        return new WithSearchClause(
                "BREADTH".equalsIgnoreCase(orderingToken.image)
                        ? WithSearchClause.SearchOrder.BREADTH
                        : WithSearchClause.SearchOrder.DEPTH,
                searchColumns, sequenceColumnName);
    }
}

WithFunctionDeclaration WithFunctionDeclaration() #WithFunctionDeclaration:
{
     String functionName;
     List<WithFunctionParameter> parameters = new ArrayList<WithFunctionParameter>();
     String returnType;
     Expression returnExpression;
     WithFunctionParameter parameter;
}
{
    functionName = RelObjectName()
    "("
        [ parameter=WithFunctionParameter() { parameters.add(parameter); }
          ( "," parameter=WithFunctionParameter() { parameters.add(parameter); } )*
        ]
    ")"
    <K_RETURNS> returnType = RelObjectName()
    <K_RETURN> returnExpression = Expression()
    {
        return new WithFunctionDeclaration(functionName, parameters, returnType, returnExpression);
    }
}

WithFunctionParameter WithFunctionParameter() #WithFunctionParameter:
{
     String name;
     String type = null;
     String arrayType = null;
}
{
    name = RelObjectName()
    (
        LOOKAHEAD(2) <K_ARRAY_LITERAL> "<" arrayType = RelObjectName() ">"
        |
        type = RelObjectName()
    )
    {
        if (arrayType != null) {
            type = "ARRAY<" + arrayType + ">";
        }
        return new WithFunctionParameter(name, type);
    }
}

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

    { return selectItemsList; }
}

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

    { return selectItemsList; }
}

FunctionAllColumns FunctionAllColumns() #FunctionAllColumns:
{
    Function function;
}
{
    "(" ( "(" )* function=Function() ")" ( ")" )* "." "*"
    {
        return new FunctionAllColumns(function);
    }
}

SelectItem<?> SelectItem() #SelectItem:
{
    Expression expression;
    Alias alias = null;
}
{
    // @fixme: Oracle's SEQUENCE.nextval is parsed as COLUMN with a name part nextval
    // @todo: parse a proper SEQUENCE instead of a COLUMN
    (
        LOOKAHEAD( 3 ) expression = ConnectByPriorOperator()
        |
        ( expression=Condition() { expression = prattExpressionRest(expression, 2); } )
    )
    [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ]
    {
        SelectItem<?> selectItem = new SelectItem(expression, alias);
        linkAST(selectItem,jjtThis);
        return selectItem;
    }
}

/**
 * Parses the AllColumns-Pattern '*'.
 *
 * If the allowAdditions is true, it parses additional Keywords.
 */
AllColumns AllColumns(boolean allowAdditions):
{
    ParenthesedExpressionList<Column> exceptColumns = null;
    List<SelectItem<?>> replaceExpressions = null;
    String exceptKeyword=null;
    Token tk;
}
{
    "*"
    // BigData allows EXCEPT, DuckDB allows EXCLUDE
    [ LOOKAHEAD(2, { allowAdditions }) ( tk=<K_EXCEPT> | tk=<K_EXCLUDE> ) exceptColumns = ParenthesedColumnList() { exceptKeyword=tk.image; } ]
    // BigData allows REPLACE
    [ LOOKAHEAD(2, { allowAdditions }) <K_REPLACE> "(" replaceExpressions = SelectItemsList() ")" ]

    {
        return new AllColumns(exceptColumns, replaceExpressions, exceptKeyword);
    }
}

/**
 * Parses the AllTableColumns-Pattern 'table.*'
 *
 * If the allowAdditions is true, it parses additional Keywords.
 */
AllTableColumns AllTableColumns(boolean allowAdditions):
{
    Table table = null;
    AllColumns allColumns;
}
{
     table=Table() "." allColumns=AllColumns(allowAdditions)
    {
        return new AllTableColumns(table, allColumns);
    }

}

Alias Alias():
{ String name = "";
  Token token = null;
  boolean useAs = false;
  Alias alias;
  String colname;
  ColDataType colDataType = null;
}
{
    (
        LOOKAHEAD(3) (
            // Aliases with AS and Columns, but optional identifier:
            //      SELECT fun(x) AS (a,b,c)
            //      SELECT fun(x) AS T(a,b,c)
            <K_AS>
            [ LOOKAHEAD(2) name=RelObjectName() ]
            { alias = new Alias(name, true ); }

            "(" { 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); }

        )
        |
        (
            // Aliases with identifier but optional AS and Columns:
            //      SELECT fun(x) AS T
            //      SELECT fun(x) T
            //      SELECT fun(x) T(a,b,c)

            [<K_AS> { useAs = true; } ]
            ( name=RelObjectName() | 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 = RelObjectName() { indexNameList.add(indexName); }
	("," indexName= RelObjectName() { indexNameList.add(indexName); })*
	")"
	{
		return new MySQLIndexHint(actionToken.image, indexToken.image, indexNameList);
	}
}

SelectItem<Function> FunctionItem():
{
    Alias alias = null;
    Function function;
}
{
    function=Function()
    [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ]
    { return new SelectItem<Function>(function, alias); }
}

ExpressionList<Column> PivotForColumns():
{
    ExpressionList<Column> columns;
    Column column;
}
{
    (
        columns = ParenthesedColumnList()
        |
        column = Column() { columns = new ExpressionList<Column>(column); }
    )
    { return columns; }
}

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

SelectItem<ExpressionList<?>> ExpressionListItem():
{
    ExpressionList expressionList;
    Alias alias = null;
}
{
    expressionList=ParenthesedExpressionList()
    [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ]
    { return new SelectItem<ExpressionList<?>>(expressionList, alias); }
}

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

Pivot Pivot():
{
    Pivot retval = new Pivot();
    List<SelectItem<Function>> functionItems;
    ExpressionList<Column> forColumns;
    List<SelectItem<?>> singleInItems = null;
    List<SelectItem<ExpressionList<?>>> multiInItems = null;
    Alias alias = null;
}
{
    <K_PIVOT> "(" functionItems = PivotFunctionItems() <K_FOR>
    forColumns = PivotForColumns()
    <K_IN> "("
    (LOOKAHEAD(3) singleInItems = SelectItemsList()
    | multiInItems = PivotMultiInItems() )
    ")"
    ")"
    [ LOOKAHEAD({ isAliasAhead() }) 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<SelectItem<Function>> functionItems;
    ExpressionList<Column> forColumns;
    List<SelectItem<?>> singleInItems = null;
    List<SelectItem<ExpressionList<?>>> multiInItems = null;
    Select inSelect = null;
}
{
    <K_PIVOT> <K_XML> "(" functionItems = PivotFunctionItems() <K_FOR>
    forColumns = PivotForColumns()
    <K_IN> "("
    (
        LOOKAHEAD(2) <K_ANY> { retval.setInAny(true); } |
        LOOKAHEAD(1) inSelect = Select() |
        LOOKAHEAD(2) singleInItems =SelectItemsList() |
        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();
    ExpressionList<Column> unpivotClause;
    ExpressionList<Column> unpivotForClause;
    List<SelectItem<?>> 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 = SelectItemsList()
    ")"
    ")"
    [ LOOKAHEAD({ isAliasAhead() }) 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;
    }
}

MySqlSelectIntoClause MySqlSelectIntoClause(MySqlSelectIntoClause.Position position):
{
    MySqlSelectIntoClause intoClause = new MySqlSelectIntoClause().withPosition(position);
    Token token;
}
{
    <K_INTO>
    (
          <K_OUTFILE> { intoClause.setType(MySqlSelectIntoClause.Type.OUTFILE); }
          token=<S_CHAR_LITERAL> { intoClause.setFileName(new StringValue(token.image)); }
          MySqlSelectIntoOutfileTail(intoClause)
        |
          <K_DUMPFILE> { intoClause.setType(MySqlSelectIntoClause.Type.DUMPFILE); }
          token=<S_CHAR_LITERAL> { intoClause.setFileName(new StringValue(token.image)); }
    )
    {
        return intoClause;
    }
}

MySqlProcedureAnalyse MySqlProcedureAnalyse():
{
    MySqlProcedureAnalyse procedureAnalyse = new MySqlProcedureAnalyse();
    Token maxElements = null;
    Token maxMemory = null;
}
{
    <K_PROCEDURE> <K_ANALYSE> "("
    [
        maxElements=<S_LONG>
        [ "," maxMemory=<S_LONG> ]
    ]
    ")"
    {
        if (maxElements != null) {
            procedureAnalyse.setMaxElements(new LongValue(maxElements.image));
        }
        if (maxMemory != null) {
            procedureAnalyse.setMaxMemory(new LongValue(maxMemory.image));
        }
        return procedureAnalyse;
    }
}

void MySqlSelectIntoOutfileTail(MySqlSelectIntoClause intoClause):
{
    Token token;
}
{
    (
          LOOKAHEAD(<K_CHARACTER> <K_SET>)
          <K_CHARACTER> <K_SET>
          (token=<S_IDENTIFIER> | token=<K_BINARY>)
          { intoClause.setCharacterSet(token.image); }
          (
                LOOKAHEAD((<K_FIELDS> | <K_COLUMNS>))
                MySqlSelectIntoFieldsClause(intoClause)
                [ LOOKAHEAD(<K_LINES>) MySqlSelectIntoLinesClause(intoClause) ]
              |
                LOOKAHEAD(<K_LINES>)
                MySqlSelectIntoLinesClause(intoClause)
              |
                { }
          )
        |
          LOOKAHEAD((<K_FIELDS> | <K_COLUMNS>))
          MySqlSelectIntoFieldsClause(intoClause)
          [ LOOKAHEAD(<K_LINES>) MySqlSelectIntoLinesClause(intoClause) ]
        |
          LOOKAHEAD(<K_LINES>)
          MySqlSelectIntoLinesClause(intoClause)
        |
          { }
    )
}

void MySqlSelectIntoFieldsClause(MySqlSelectIntoClause intoClause):
{
    Token token;
}
{
    (
          <K_FIELDS> { intoClause.setFieldsKeyword(MySqlSelectIntoClause.FieldsKeyword.FIELDS); }
        | <K_COLUMNS> { intoClause.setFieldsKeyword(MySqlSelectIntoClause.FieldsKeyword.COLUMNS); }
    )
    (
          LOOKAHEAD(<K_TERMINATED> <K_BY>)
          <K_TERMINATED> <K_BY> token=<S_CHAR_LITERAL>
          { intoClause.setFieldsTerminatedBy(new StringValue(token.image)); }
          (
                LOOKAHEAD((<K_OPTIONALLY> | <K_ENCLOSED>))
                [ <K_OPTIONALLY> { intoClause.setFieldsOptionallyEnclosed(true); } ]
                <K_ENCLOSED> <K_BY> token=<S_CHAR_LITERAL>
                { intoClause.setFieldsEnclosedBy(new StringValue(token.image)); }
                [ LOOKAHEAD(<K_ESCAPED> <K_BY>)
                    <K_ESCAPED> <K_BY> token=<S_CHAR_LITERAL>
                    { intoClause.setFieldsEscapedBy(new StringValue(token.image)); }
                ]
              |
                LOOKAHEAD(<K_ESCAPED> <K_BY>)
                <K_ESCAPED> <K_BY> token=<S_CHAR_LITERAL>
                { intoClause.setFieldsEscapedBy(new StringValue(token.image)); }
              |
                { }
          )
        |
          LOOKAHEAD((<K_OPTIONALLY> | <K_ENCLOSED>))
          [ <K_OPTIONALLY> { intoClause.setFieldsOptionallyEnclosed(true); } ]
          <K_ENCLOSED> <K_BY> token=<S_CHAR_LITERAL>
          { intoClause.setFieldsEnclosedBy(new StringValue(token.image)); }
          [ LOOKAHEAD(<K_ESCAPED> <K_BY>)
              <K_ESCAPED> <K_BY> token=<S_CHAR_LITERAL>
              { intoClause.setFieldsEscapedBy(new StringValue(token.image)); }
          ]
        |
          LOOKAHEAD(<K_ESCAPED> <K_BY>)
          <K_ESCAPED> <K_BY> token=<S_CHAR_LITERAL>
          { intoClause.setFieldsEscapedBy(new StringValue(token.image)); }
        |
          { }
    )
}

void MySqlSelectIntoLinesClause(MySqlSelectIntoClause intoClause):
{
    Token token;
}
{
    <K_LINES>
    (
          LOOKAHEAD(<K_STARTING> <K_BY>)
          <K_STARTING> <K_BY> token=<S_CHAR_LITERAL>
          { intoClause.setLinesStartingBy(new StringValue(token.image)); }
          [ LOOKAHEAD(<K_TERMINATED> <K_BY>)
              <K_TERMINATED> <K_BY> token=<S_CHAR_LITERAL>
              { intoClause.setLinesTerminatedBy(new StringValue(token.image)); }
          ]
        |
          LOOKAHEAD(<K_TERMINATED> <K_BY>)
          <K_TERMINATED> <K_BY> token=<S_CHAR_LITERAL>
          { intoClause.setLinesTerminatedBy(new StringValue(token.image)); }
        |
          { }
    )
}

FromItem ParenthesedFromItem():
{
    ParenthesedFromItem ParenthesedFromItem = new ParenthesedFromItem();
    FromItem fromItem;
    List<Join> joins = null;
}
{
    "("
        fromItem = FromItem()
        [ joins=JoinsList() ]
    ")"

    {
        return ParenthesedFromItem.withFromItem(fromItem).withJoins(joins);
    }
}

FromItem FromItem() #FromItem:
{
    FromItem fromItem = null;
    FromItem fromItem2 = null;
    SampleClause sampleClause;
    Pivot pivot = null;
    UnPivot unpivot = null;
    Alias alias = null;
    MySQLIndexHint indexHint = null;
    SQLServerHints sqlServerHints = null;
    Select select;

    String timeTravelStr = null;
}
{
    (
        LOOKAHEAD(3, { !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) fromItem = Values()
        |
        LOOKAHEAD({
            getToken(1).kind == S_IDENTIFIER
                && getToken(1).image.equalsIgnoreCase("JSON_TABLE")
                && getToken(2).kind == OPENING_BRACKET
        }) fromItem=TableFunction()
        |
        LOOKAHEAD({
            getToken(1).kind == K_LATERAL
                && getToken(2).kind == S_IDENTIFIER
                && getToken(2).image.equalsIgnoreCase("JSON_TABLE")
                && getToken(3).kind == OPENING_BRACKET
        }) fromItem=TableFunction()
        |
        LOOKAHEAD({
            (getToken(1).kind == K_ROWS
                && getToken(2).kind == K_FROM
                && getToken(3).kind == OPENING_BRACKET)
            || (isFunctionAhead() && getToken(1).kind != K_LATERAL)
            || (getToken(1).kind == K_LATERAL && getToken(2).kind != OPENING_BRACKET) })
        fromItem=TableFunction()
        |
        LOOKAHEAD(3) fromItem=Table()
        |
        LOOKAHEAD({ isNestedSetOperationAhead() }) (
            fromItem=ParenthesedSelect()
            [ LOOKAHEAD(2) pivot=Pivot() { fromItem.setPivot(pivot); } ]
            [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ]
        )
        |
        LOOKAHEAD({ isParenthesedFromItemAhead() }) fromItem = ParenthesedFromItem()
        |
        LOOKAHEAD(3, { !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) (
            fromItem=ParenthesedSelect()
            [ LOOKAHEAD(2) pivot=Pivot() { fromItem.setPivot(pivot); } ]
            [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ]
        )
        |
        fromItem=LateralSubSelect()
        |
        LOOKAHEAD(2, { Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) fromItem=SubImport() { fromItem = new ParenthesedFromItem(fromItem); }
        |
        LOOKAHEAD({ getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) fromItem=Select()
    )

    [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { fromItem.setAlias(alias); } ]
    [
        LOOKAHEAD(2, {fromItem instanceof Table }) timeTravelStr = TimeTravelAfterAlias()
        { ((Table) fromItem).setTimeTravelStrAfterAlias(timeTravelStr); }
    ]
    [ LOOKAHEAD(2) sampleClause = SampleClause() { fromItem.setSampleClause(sampleClause); } ]
    [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ]
    [ LOOKAHEAD(2) ( 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);
            }
        )
    ]
    {
        linkAST(fromItem,jjtThis);
        return fromItem;
    }
}

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

JoinHint JoinHint():
{
    Token token;
}
{
    (
        token = <K_LOOP>
        |
        token = <K_HASH>
        |
        token = <K_MERGE>
        |
        token = <K_REMOTE>
    )
    {
        return new JoinHint(token.image);
    }
}

Join JoinerExpression() #JoinerExpression:
{
    Join join = new Join();
    FromItem right = null;
    Expression onExpression = null;
    Column tableColumn;
    List<Column> columns = null;
    KSQLJoinWindow joinWindow = null;
    JoinHint joinHint = null;
}
{
    [ <K_GLOBAL> { join.setGlobal(true); } ]
    [ <K_ANY> { join.setAny(true); } | <K_ALL> { join.setAll(true); } ]
    [ <K_NATURAL> { join.setNatural(true); } ]

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

    [ <K_ARRAY_LITERAL> { join.setArray(true); } ]

    (
        (
            [ joinHint=JoinHint() {join.setJoinHint(joinHint); } ]
            <K_JOIN>
            [ <K_FETCH> { join.setFetch(true); } ]
        )
        |
        "," { 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.setFromItem(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(KSQLWindow.TimeUnit.from(beforeTimeUnitToken.image));
            retval.setBeforeAfterWindow(false);
            return retval;
        }
        retval.setBeforeDuration(Long.parseLong(beforeDurationToken.image));
        retval.setBeforeTimeUnit(KSQLWindow.TimeUnit.from(beforeTimeUnitToken.image));
        retval.setAfterDuration(Long.parseLong(afterDurationToken.image));
        retval.setAfterTimeUnit(KSQLWindow.TimeUnit.from(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.from(sizeTimeUnitToken.image));
            if (advanceDurationToken != null) {
                retval.setAdvanceDuration(Long.parseLong(advanceDurationToken.image));
                retval.setAdvanceTimeUnit(KSQLWindow.TimeUnit.from(advanceTimeUnitToken.image));
            }
            return retval;
    }
}

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

Expression PreWhereClause():
{
    Expression retval = null;
}
{
    <K_PREWHERE> retval=Expression()
    { return retval; }
}

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

PreferringClause PreferringClause():
{
    Expression result = null;
}
{
    <K_PREFERRING>
    result=PreferenceTerm()

    {
        PreferringClause preferring = new PreferringClause(result);
        return preferring;
    }
}

Expression PreferenceTerm():
{
    Expression retval = null;
}
{
    // recursively build preferenceterm inside Plus
    // like Expression -> XorExpression -> OrExpression -> ...

    retval=Plus()

    {
        return retval;
    }
}

Expression Plus():
{
    Expression left, right, result;
}
{
    left=PriorTo() { result = left; }
    (
        LOOKAHEAD(2)
        <K_PLUS>
        right=PriorTo()
        {
          result = new Plus(left, right);
          left = result;
        }
    )*
    {
        return result;
    }
}

Expression PriorTo():
{
    Expression left, right, result;
}
{
    (
        LOOKAHEAD(3) left=PreferenceTermTerminal()
        |
        "(" left=PreferenceTerm() ")" { left = new ParenthesedExpressionList(left); }
    )
    { result = left; }

    (
        LOOKAHEAD(2) <K_PRIOR> <K_TO>
        (
            LOOKAHEAD(3) right=PreferenceTermTerminal()
            |
            "(" right=PreferenceTerm() ")" { left = new ParenthesedExpressionList(right); }
        )
        {
            result = new PriorTo(left, right);
            left = result;
        }
    )*
    {
        return result;
    }
}

Expression PreferenceTermTerminal():
{
    Expression retval;
}
{
    (
        LOOKAHEAD(2) retval=HighExpression()
        |
        LOOKAHEAD(2) retval=LowExpression()
        |
        LOOKAHEAD(2) retval=Inverse()
        |
        retval=Condition()
    )

    {
        return retval;
    }
}

Expression HighExpression() #HighExpression:
{
    Expression result;
}
{
    <K_HIGH>
    result=Expression()

    {
        HighExpression high = new HighExpression(result);
        linkAST(high,jjtThis);
        return high;
    }
}

Expression LowExpression() #LowExpression:
{
    Expression result;
}
{
    <K_LOW>
    result=Expression()

    {
        LowExpression low = new LowExpression(result);
        linkAST(low,jjtThis);
        return low;
    }
}

Expression Inverse() #Inverse:
{
    Expression result;
}
{
    <K_INVERSE>
    "(" result=PreferenceTerm() ")"

    {
        Inverse inverse = new Inverse(result);
        linkAST(inverse,jjtThis);
        return inverse;
    }
}

GroupByElement GroupByColumnReferences():
{
    Expression columnReference;
    GroupByElement groupBy = new GroupByElement();
    Expression expr;
    ExpressionList<Expression> list;
    Token token;
}
{
    <K_GROUP> <K_BY>
    (
        LOOKAHEAD(2) (
            <K_GROUPING> <K_SETS>
            "("
                list = GroupingSet() { groupBy.addGroupingSet(list); }
                ( LOOKAHEAD(2) "," list = GroupingSet() { groupBy.addGroupingSet(list); })*
            ")"
        )
        |
        (
            list = ExpressionList() { groupBy.setGroupByExpressions(list); }
            (
                LOOKAHEAD(2) <K_GROUPING> <K_SETS>
                "("
                    list = GroupingSet() { groupBy.addGroupingSet(list); }
                    ( LOOKAHEAD(2) "," list = GroupingSet() { groupBy.addGroupingSet(list); })*
                ")"
            )?
            [ LOOKAHEAD(2) <K_WITH> <K_ROLLUP> { groupBy.setMysqlWithRollup(true); }  ]
        )
    )
    {
        return groupBy;
    }
}

ExpressionList<Expression> GroupingSet():
{
    ExpressionList<Expression> list;
    Expression expression;
}
{
    (
        LOOKAHEAD(2) list = ParenthesedExpressionList()
        |
        expression = SimpleExpression() { list = new ExpressionList<Expression>(expression); }
    )
    {
        return list;
    }
}

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

Expression Qualify():
{
    Expression qualify = null;
}
{
    <K_QUALIFY> qualify=Expression()
    {
        return qualify;
    }
}

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;
    Token collateToken = null;
    WithFill withFill = null;
}
{
    columnReference = Expression()
    [ LOOKAHEAD(<K_COLLATE>) <K_COLLATE> (collateToken=<S_CHAR_LITERAL> | collateToken=<S_QUOTED_IDENTIFIER>) { columnReference = new CollateExpression(columnReference, collateToken.image); } ]
    [ LOOKAHEAD(2) ( <K_ASC> | (<K_DESC> { orderByElement.setAsc(false); } )) { orderByElement.setAscDescPresent(true); }  ]
    [ LOOKAHEAD(2) <K_NULLS>
        [ LOOKAHEAD(2) (
            <K_FIRST> { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_FIRST);  }
            |
            <K_LAST> { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_LAST);  }
            )
        ]
    ]
    [ LOOKAHEAD(2) withFill = WithFill() { orderByElement.setWithFill(withFill); } ]
    [ LOOKAHEAD(2) <K_WITH> <K_ROLLUP> { orderByElement.setMysqlWithRollup(true); } ]
    {
        orderByElement.setExpression(columnReference);
        return orderByElement;
    }
}

WithFill WithFill():
{
    WithFill withFill = new WithFill();
    Expression fillExpression = null;
}
{
    <K_WITH> <K_FILL>
    [ LOOKAHEAD(2) <K_FROM> fillExpression = Expression() { withFill.setFrom(fillExpression); } ]
    [ LOOKAHEAD(2) <K_TO> fillExpression = Expression() { withFill.setTo(fillExpression); } ]
    [ LOOKAHEAD(2) <K_STEP> fillExpression = Expression() { withFill.setStep(fillExpression); } ]
    [ LOOKAHEAD(2) <K_STALENESS> fillExpression = Expression() { withFill.setStaleness(fillExpression); } ]
    { return withFill; }
}

List<InterpolateElement> InterpolateClause():
{
    List<InterpolateElement> interpolateElements = new ArrayList<InterpolateElement>();
    InterpolateElement interpolateElement = null;
}
{
    <K_INTERPOLATE>
    [ "("
        [ interpolateElement = InterpolateElement() { interpolateElements.add(interpolateElement); }
          ( "," interpolateElement = InterpolateElement() { interpolateElements.add(interpolateElement); } )*
        ]
    ")" ]
    { return interpolateElements; }
}

InterpolateElement InterpolateElement():
{
    InterpolateElement interpolateElement = new InterpolateElement();
    Column column = null;
    Expression expression = null;
}
{
    column = Column() { interpolateElement.setColumn(column); }
    [ <K_AS> expression = Expression() { interpolateElement.setExpression(expression); } ]
    { return interpolateElement; }
}

Expression OptionHintParameter():
{
    UserVariable userVariable = null;
    Expression parameter = null;
}
{
    (
        LOOKAHEAD({ getToken(1).kind == S_AT_IDENTIFIER && getToken(2).kind == K_UNKNOWN })
        userVariable = UserVariable() <K_UNKNOWN>
        {
            return new Column(userVariable + " UNKNOWN");
        }
        |
        parameter = Expression() { return parameter; }
    )
}

OptionClause OptionClause():
{
    OptionClause optionClause = new OptionClause();
    OptionHint optionHint = null;
}
{
    <K_OPTION> "(" optionHint = OptionHint() { optionClause.addOptionHint(optionHint); }
    ( "," optionHint = OptionHint() { optionClause.addOptionHint(optionHint); } )*
    ")"
    { return optionClause; }
}

OptionHint OptionHint():
{
    OptionHint optionHint = new OptionHint();
    String name = null;
    Expression value = null;
    Expression parameter = null;
}
{
    name = OptionHintName() { optionHint.setName(name); }
    [
        (
            LOOKAHEAD("=") "=" value = Expression() { optionHint.setValue(value); optionHint.setUseEquals(true); }
            |
            LOOKAHEAD("(") "(" parameter = OptionHintParameter() { optionHint.addParameter(parameter); }
            ( "," parameter = OptionHintParameter() { optionHint.addParameter(parameter); } )*
            ")"
            |
            LOOKAHEAD({ isOptionHintValueAhead() }) value = Expression() { optionHint.setValue(value); }
        )
    ]
    { return optionHint; }
}

String OptionHintName():
{
    Token tk = null;
    String word = null;
    StringBuilder name = new StringBuilder();
}
{
    (
        LOOKAHEAD({ isOptionHintWordAhead() })
        ( tk=<S_IDENTIFIER> | word = NonReservedWord()
          | tk=<K_JOIN> | tk=<K_FOR> | tk=<K_ORDER>
          | tk=<K_UNION> | tk=<K_EXCEPT> | tk=<K_INTERSECT>
          | tk=<K_USE> | tk=<K_OPTIMIZE> | tk=<K_FORCE> | tk=<K_UNKNOWN> )
        {
            if (name.length() > 0) { name.append(' '); }
            name.append(tk != null ? tk.image : word);
            tk = null;
            word = null;
        }
    )+
    { return name.toString(); }
}

JdbcParameter JdbcParameter() : {
    Token tk;
    JdbcParameter retval;
}
{
    ( tk="?" | tk=<S_PARAMETER> )
    { retval = new JdbcParameter(++jdbcParameterIndex, false, tk.image); }

    [ LOOKAHEAD(2) token = <S_LONG> { retval.setUseFixedIndex(true); retval.setIndex(Integer.valueOf(token.image)); } ]

    { return retval; }
}


Limit LimitWithOffset() #LimitWithOffset:
{
    Limit limit = new Limit();
    Expression firstExpression;
    Expression secondExpression;
}
{
    <K_LIMIT>
    (
        LOOKAHEAD(3) firstExpression = ParenthesedSelect()
        |
        firstExpression = Expression()
    )
    (
        // MySQL: LIMIT offset, row_count
        ","
        secondExpression = Expression()
        {
            limit.setOffset(firstExpression);
            limit.setRowCount(secondExpression);
        }
        |
        // PostgreSQL: LIMIT row_count
        {
            limit.setRowCount(firstExpression);
        }
    )
    {
        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 = ParenthesedSelect()
            |
            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 ); }

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

        )
    {
        return offset;
    }
}

Fetch Fetch():
{
    Fetch fetch = new Fetch();
    Token token = null;
    Expression expression;
    List<String> fetchParameters = new ArrayList<String>();
}
{
    (
        LOOKAHEAD(3) (
            <K_FETCH> (<K_FIRST> { fetch.setFetchParamFirst(true); } | <K_NEXT>)
            (
                <K_ROWS> { fetch.addFetchParameter("ROWS"); }
                |
                <K_ROW> { fetch.addFetchParameter("ROW"); }
            )
            (
                <K_ONLY> { fetch.addFetchParameter("ONLY"); }
                |
                <K_WITH_TIES> { fetch.addFetchParameter("WITH TIES"); }
            )
        )
        |
        (
            <K_FETCH> (<K_FIRST> { fetch.setFetchParamFirst(true); } | <K_NEXT>)

            // Expression is optional according to https://www.h2database.com/html/commands.html#select
            expression = Expression() { fetch.setExpression(expression); }
            [ <K_PERCENT> { fetch.addFetchParameter("PERCENT"); } ]
            (
                (
                    <K_ROWS> { fetch.addFetchParameter("ROWS"); }
                    |
                    <K_ROW> { fetch.addFetchParameter("ROW"); }
                )

                (
                    <K_ONLY> { fetch.addFetchParameter("ONLY"); }
                    |
                    <K_WITH_TIES> { fetch.addFetchParameter("WITH TIES"); }
                )
            )
        )
    )
    {
        return fetch;
    }
}

WithIsolation WithIsolation():
{
    WithIsolation withIsolation = new WithIsolation();
    Token token = null;
    JdbcParameter jdbc;
}
{
    <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 top = new Top();
    Token token = null;
    Expression expr = null;
    JdbcParameter jdbc = null;
}
{
    <K_TOP>
    (
        token=<S_LONG> { top.setExpression(new LongValue(token.image)); }
        |
        jdbc = JdbcParameter() { top.setExpression(jdbc); }
        |
        ":" { top.setExpression(new JdbcNamedParameter()); }
        [ LOOKAHEAD(2) token = <S_IDENTIFIER> { ((JdbcNamedParameter)top.getExpression()).setName(token.image); } ]
        |
        "("
        expr=SimpleExpression()
        {
            top.setExpression(expr);
            top.setParenthesis(true);
        }
        ")"
    )
    [ LOOKAHEAD(2) <K_PERCENT> { top.setPercentage(true); } ]
    [ LOOKAHEAD(2) <K_WITH_TIES> { top.setWithTies(true); } ]
    {
        linkAST(top,jjtThis);
        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 = JdbcParameter() { skip.setJdbcParameter(jdbc); }
    )
    {
        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 = JdbcParameter() { first.setJdbcParameter(jdbc); }
    )
    {
        return first;
    }
}


Expression Expression() #Expression :
{
    Expression expression = null;
}
{
    expression=Condition()
    { expression = prattExpressionRest(expression, 2); }
    {
        linkAST(expression,jjtThis);
        return expression;
    }
}

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

/** AND — higher precedence than OR/XOR */
Expression AndChain():
{
    Expression result;
    Expression right;
}
{
    result=Condition()
    (
        LOOKAHEAD(2)
        (
            <K_AND> right=Condition() {{
                AndExpression a = new AndExpression(result, right); result = a;
            }}
            |
            <OP_DOUBLEAND> right=Condition() {{
                AndExpression a = new AndExpression(result, right);
                a.setUseOperator(true); result = a;
            }}
        )
    )*
    { return result; }
}

Expression Condition():
{
    Expression result;
    Expression left;
    boolean not = false;
    boolean exclamationMarkNot = false;
    int oraclePrior = EqualsTo.NO_ORACLE_PRIOR;
    int oracleJoin = EqualsTo.NO_ORACLE_JOIN;
}
{
    [ LOOKAHEAD(2, { getToken(1).kind == K_NOT || "!".equals(getToken(1).image) }) (<K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; })]
    (
        result=ExistsExpression()
        |
          [ LOOKAHEAD(2, { getToken(1).kind == K_PRIOR }) <K_PRIOR> { oraclePrior = EqualsTo.ORACLE_PRIOR_START; } ]
          left=SimpleExpression() { result = left; }

          // Consume Oracle (+) once, before dispatching
          [
              LOOKAHEAD("(" "+" ")", { getToken(1).kind == OPENING_BRACKET })
              "(" "+" ")"
              {
                  oracleJoin = EqualsTo.ORACLE_JOIN_RIGHT;
                  if (left instanceof Column) {
                      ((Column) left).setOldOracleJoinSyntax(oracleJoin);
                  }
              }
          ]

          // Single guard: only enter if next token can start a condition suffix
            [
                LOOKAHEAD({ isConditionSuffixAhead() })
                (
                    LOOKAHEAD({ isComparisonOperatorAhead() })
                        result = RegularConditionRHS(left, oracleJoin)
                    | LOOKAHEAD(2) result = OverlapsCondition(left)
                    | LOOKAHEAD(3) result=InExpression(left)
                    | LOOKAHEAD(3) result=ExcludesExpression(left)
                    | LOOKAHEAD(3) result=IncludesExpression(left)
                    | LOOKAHEAD(2) result=Between(left)
                    | LOOKAHEAD(2) result = MemberOfExpression(left)
                    | LOOKAHEAD(3) result=IsNullExpression(left)
                    | LOOKAHEAD(3) result=IsBooleanExpression(left)
                    | LOOKAHEAD(3) result=IsUnknownExpression(left)
                    | LOOKAHEAD(2) result=LikeExpression(left)
                    | LOOKAHEAD(3) result=IsDistinctExpression(left)
                    | result=SimilarToExpression(left)
                )
            ]
    )
    {
        if (oraclePrior == EqualsTo.ORACLE_PRIOR_START
                && result instanceof SupportsOldOracleJoinSyntax) {
            ((SupportsOldOracleJoinSyntax) result).setOraclePriorPosition(oraclePrior);
        }
        return not ? new NotExpression(result, exclamationMarkNot) : result;
    }
}

Expression RegularConditionRHS(Expression leftExpression, int oracleJoinRight) #RegularCondition:
{
    Expression result = null;
    Expression rightExpression;
    int oracleJoin = EqualsTo.NO_ORACLE_JOIN;
    int oraclePrior = EqualsTo.NO_ORACLE_PRIOR;
    Token token;
}
{
    // Only consume (+) here if it wasn't already consumed by Condition
    [ LOOKAHEAD("(" "+" ")") "(" "+" ")" { 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); }
        | token=<OP_NOTEQUALSHAT> { result = new NotEqualsTo(token.image); }
        | "*=" { result = new TSQLLeftJoin(); }
        | "=*" { result = new TSQLRightJoin(); }
        | token=<OP_DOUBLEAND> { result = new DoubleAnd(); }
        | token=<OP_CONTAINS> { result = new Contains(); }
        | token=<OP_CONTAINEDBY> { result = new ContainedBy(); }
        | "@@" { result = new Matches(); }
        | "~" { result = new RegExpMatchOperator(RegExpMatchOperatorType.MATCH_CASESENSITIVE); }
        | "~*" { 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("<#>"); }
        | <OP_COSINESIMILARITY> { result = new CosineSimilarity(); }
    )

    ( 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 OverlapsCondition(Expression leftExpression):
{
    ExpressionList right;
}
{
    <K_OVERLAPS>
    right = ParenthesedExpressionList()
    {
        ExpressionList left;
        if (leftExpression instanceof ExpressionList) {
            left = (ExpressionList) leftExpression;
        } else {
            left = new ExpressionList(leftExpression);
        }
        return new OverlapsCondition(left, right);
    }
}

Expression SQLCondition():
{
    Expression result;
    Expression left;
}
{
    (
    result=ExistsExpression()
    | left = SimpleExpression() { result = left; }
        [
            LOOKAHEAD(2) (
                LOOKAHEAD(2, <K_OVERLAPS>) result=OverlapsCondition(left)
                |
                LOOKAHEAD(3, {!interrupted}) result=InExpression(left)
                |
                LOOKAHEAD(3) result=ExcludesExpression(left)
                |
                LOOKAHEAD(3) result=IncludesExpression(left)
                |
                LOOKAHEAD(2) result=Between(left)
                |
                result = MemberOfExpression(left)
                |
                LOOKAHEAD(3) result=IsNullExpression(left)
                |
                LOOKAHEAD(3) result=IsBooleanExpression(left)
                |
                LOOKAHEAD(3) result=IsUnknownExpression(left)
                |
                LOOKAHEAD(2) result=LikeExpression(left)
                |
                LOOKAHEAD(3) result=IsDistinctExpression(left)
                |
                result=SimilarToExpression(left)
            )
        ]
    )
    { return result; }
}

Expression InExpression(Expression leftExpression) #InExpression :
{
    Token token;
    int oldOracleJoin = 0;
    boolean usingNot = false;
    boolean usingGlobal = false;
    Expression rightExpression;
}
{
    [ "(" "+" ")" { oldOracleJoin=EqualsTo.ORACLE_JOIN_RIGHT; } ]

    [<K_GLOBAL> { usingGlobal=true; } ]
    [<K_NOT> { usingNot=true; } ]
    <K_IN>
    (
        LOOKAHEAD(2) token=<S_CHAR_LITERAL> {  rightExpression = new StringValue(token.image); }
        |
        LOOKAHEAD({ isNestedSetOperationAhead() }) rightExpression = ParenthesedSelect()
        |
        rightExpression = PrimaryExpression()
    )
    {
        InExpression inExpression =  new InExpression(leftExpression, rightExpression)
                                                .withOldOracleJoinSyntax(oldOracleJoin)
                                                .withNot(usingNot)
                                                .setGlobal(usingGlobal);
        linkAST(inExpression,jjtThis);
        return inExpression;
    }
}

Expression IncludesExpression(Expression leftExpression) #IncludesExpression :
{
    Token token;
    Expression rightExpression;
}
{
    <K_INCLUDES> (rightExpression = ParenthesedExpressionList())
    {
        IncludesExpression includesExpression =  new IncludesExpression(leftExpression, rightExpression);

        linkAST(includesExpression,jjtThis);
        return includesExpression;
    }
}

Expression ExcludesExpression(Expression leftExpression) #ExcludesExpression :
{
    Token token;
    Expression rightExpression;
}
{
    <K_EXCLUDES> (rightExpression = ParenthesedExpressionList())
    {
        ExcludesExpression excludesExpression =  new ExcludesExpression(leftExpression, rightExpression);

        linkAST(excludesExpression,jjtThis);
        return excludesExpression;
    }
}

Expression Between(Expression leftExpression) :
{
    Between result = new Between();
    Expression betweenExpressionStart = null;
    Expression betweenExpressionEnd = null;
}
{
        [<K_NOT> { result.setNot(true); }]
        <K_BETWEEN>
        [
            LOOKAHEAD(2) (
                <K_SYMMETRIC> { result.setUsingSymmetric(true); }
                |
                <K_ASYMMETRIC> { result.setUsingAsymmetric(true); }
            )
        ]
        (
            LOOKAHEAD({ isParenthesedSelectAhead() }) betweenExpressionStart = ParenthesedSelect()
            |
            betweenExpressionStart = SimpleExpression()
            [
                LOOKAHEAD({ isComparisonOperatorAhead() })
                betweenExpressionStart = RegularConditionRHS(betweenExpressionStart, EqualsTo.NO_ORACLE_JOIN)
            ]
        )

        <K_AND>
        (
            LOOKAHEAD({ isParenthesedSelectAhead() }) betweenExpressionEnd = ParenthesedSelect()
            |
            betweenExpressionEnd = SimpleExpression()
            [
                LOOKAHEAD({ isComparisonOperatorAhead() })
                betweenExpressionEnd = RegularConditionRHS(betweenExpressionEnd, EqualsTo.NO_ORACLE_JOIN)
            ]
        )

    {
        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;
    Token token;
}
{
    [<K_NOT> { result.setNot(true); } ]
    (
        token = <K_LIKE>
        | token = <K_ILIKE>
        | token = <K_RLIKE>
        | token = <K_REGEXP_LIKE>
        | token = <K_REGEXP>
        | token = <K_SIMILAR_TO>
        | token = <K_MATCH_ANY>
        | token = <K_MATCH_ALL>
        | token = <K_MATCH_PHRASE>
        | token = <K_MATCH_PHRASE_PREFIX>
        | token = <K_MATCH_REGEXP>
    ) { result.setLikeKeyWord( LikeExpression.KeyWord.from(token.image)); }
    [ LOOKAHEAD(2) <K_BINARY> {result.setUseBinary(true); } ]
    rightExpression=SimpleExpression()
    [ LOOKAHEAD(2) <K_ESCAPE>
        (
            LOOKAHEAD(2)  token = <S_CHAR_LITERAL> { result.setEscape( new StringValue( token.image ) ); }
            |
            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()
    [ LOOKAHEAD(2) <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_NOT> { result.setNot(true); } ] <K_ISNULL> { result.setUseIsNull(true); }
        | <K_NOTNULL> { result.setUseIsNull(true); result.setUseNotNull(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 IsUnknownExpression(Expression leftExpression):
{
    IsUnknownExpression result = new IsUnknownExpression();
}
{
        (
          <K_IS> [<K_NOT> { result.setNot(true); } ] <K_UNKNOWN>
        )

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

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

Expression MemberOfExpression(Expression leftExpression):
{
    MemberOfExpression result;
    Expression rightExpression = null;
}
{
    <K_MEMBER> <K_OF> rightExpression=Expression()
    {
        return new MemberOfExpression(leftExpression, rightExpression );
    }
}

ExpressionList ExpressionList() #ExpressionList:
{
    ExpressionList expressionList;
}
{
    (
        LOOKAHEAD(3, { !interrupted }) expressionList = ComplexExpressionList()
        |
        LOOKAHEAD(3) expressionList = SimpleExpressionList()
        |
        LOOKAHEAD(3) expressionList = ParenthesedExpressionList()
        |
        // Fallback, see isUnparenthesizedSelectAhead(): the three probes above are
        // syntactic and cannot see through the Pratt operator loop, which lives in a
        // Java action. They all fail on a bracketed operand of a larger expression,
        // e.g. "( 1 + a ) / ( 1 + b )" or "( 1 + a )" - the third token is an operator
        // where the probe expects "," or ")". Such input is still a valid expression
        // list, so parse it as one instead of raising a ParseException.
        LOOKAHEAD({ !interrupted }) expressionList = ComplexExpressionList()
        |
        expressionList = SimpleExpressionList()
    )
    {
        // Avoid redundant ExpressionLists containing only one ParenthesedExpressionList
        // return the Parenthesed Sub ExpressionList instead
        // Same for ParenthesedExpressionList containing only 1 ExpressionList

        if ( expressionList.size() == 1 && expressionList.get(0) instanceof ExpressionList ) {
            ExpressionList subList = (ExpressionList) expressionList.get(0);
            if (expressionList instanceof ParenthesedExpressionList) {
                if (subList instanceof ParenthesedExpressionList) {
                    return expressionList;
                } else {
                    return new ParenthesedExpressionList(subList);
                }
            } else {
                if (subList instanceof ParenthesedExpressionList) {
                    return new ParenthesedExpressionList(subList);
                } else {
                    return subList;
                }
            }
        }
        return expressionList;
    }
}

ParenthesedExpressionList ParenthesedExpressionList():
{
    ExpressionList expressions=new ExpressionList();
}
{
    "("
    (
        LOOKAHEAD({ !interrupted }) expressions = ComplexExpressionList()
        |
        expressions = SimpleExpressionList()
    )?
    ")"
    {
        return new ParenthesedExpressionList(expressions);
    }
}

ExpressionList SimpleExpressionList():
{
    ExpressionList<Column> columns;
    ExpressionList expressions = new ExpressionList();
    Expression expr;
}
{
    expr=SimpleExpression() { expressions.add(expr); }
    (
        LOOKAHEAD(2, {!interrupted} ) ","
        (
            LOOKAHEAD( 7 ) expr=LambdaExpression()
            |
            expr=SimpleExpression()
        )
        {
            expressions.add(expr);
        }
    )*
    {
        return expressions;
    }
}


ExpressionList<Column> ColumnList():
{
    ExpressionList<Column> expressions = new ExpressionList<Column>();
    Column expr;
}
{
    expr=Column() { expressions.add(expr); }
    ( LOOKAHEAD(2) "," expr=Column() { expressions.add(expr); } )*
    {
        return expressions;
    }
}

ParenthesedExpressionList<Column> ParenthesedColumnList():
{
    ExpressionList<Column> expressions;
}
{
    "(" expressions = ColumnList() ")"
    {
        return new ParenthesedExpressionList<Column>(expressions);
    }
}

ExpressionList ComplexExpressionList():
{
    ExpressionList<Column> columns;
    ExpressionList expressions = new ExpressionList();
    Expression expr;
}
{
    (
        LOOKAHEAD(2) expr=OracleNamedFunctionParameter()
        |
        LOOKAHEAD(2) expr=PostgresNamedFunctionParameter()
        |
        expr=Expression()
    )
    {
        expressions.add(expr);
    }

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

    {
        return expressions;
    }
}

// @Todo: Refactor this with proper SQL:2016 functions according to https://manticore-projects.com/SQL2016Parser/syntax.html#character-value-function
// substring(expr1 from expr2)
// substring(expr1 from expr2 for expr3)
// trim(expr1 from expr2)   <-- Superceded by TrimFunction() below
// 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;
    }
}

Expression ComparisonItem() :
{
    Expression retval = null;
}
{
  (
    LOOKAHEAD(6, { getToken(1).kind == K_ANY || getToken(1).kind == K_SOME || getToken(1).kind == K_ALL }) retval=AnyComparisonExpression()
    |
    LOOKAHEAD({ getToken(1).kind == K_ROW }) retval=RowConstructor()
    |
    retval=SimpleExpression()
  )

   {
      return retval;
   }
}

Expression AnyComparisonExpression() :
{
    AnyType anyType;
    Select select;
}
{
    (
        <K_ANY> { anyType = AnyType.ANY; }
        |
        <K_SOME> { anyType = AnyType.SOME; }
        |
        <K_ALL> { anyType = AnyType.ALL; }
    )
    select = ParenthesedSelect()
    {
      return new AnyComparisonExpression(anyType, select);
    }
}

Expression SimpleExpression():
{
    Expression retval = null;
    UserVariable user = null;
    Token operation = null;
}
{
    [ LOOKAHEAD( 5, { getToken(1).kind == S_AT_IDENTIFIER } ) user = UserVariable() ( operation = "=" | operation = ":=" ) ]
    retval=PrimaryExpression()
    { retval = prattArithRest(retval, 5); }
    {
        if (user != null) {
            VariableAssignment assignment = new VariableAssignment();
            assignment.setVariable(user);
            assignment.setOperation(operation.image);
            assignment.setExpression(retval);
            return assignment;
        } else
            return retval;
    }
}

/** Multiplicative/bitwise-shift — higher precedence */
Expression MulChain():
{
    Expression retval;
    Expression right;
}
{
    retval=PrimaryExpression()
    (
        LOOKAHEAD(2)
        (
            "*"          right=PrimaryExpression() {{ Multiplication r = new Multiplication(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            <OP_SLASH>   right=PrimaryExpression() {{ Division r = new Division(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            "%"          right=PrimaryExpression() {{ Modulo r = new Modulo(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            <OP_CARET>   right=PrimaryExpression() {{ net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            <K_DIV>      right=PrimaryExpression() {{ IntegerDivision r = new IntegerDivision(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
        )
    )*
    { return retval; }
}

/** Additive/concat/bitwise — lower precedence */
Expression AddChain():
{
    Expression retval;
    Expression right;
}
{
    retval=MulChain()
    (
        LOOKAHEAD(2)
        (
            "+"           right=MulChain() {{ Addition r = new Addition(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            "-"           right=MulChain() {{ Subtraction r = new Subtraction(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            <OP_CONCAT>   right=MulChain() {{ Concat r = new Concat(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            LOOKAHEAD(2) <OP_PIPE> <OP_PIPE>  right=MulChain() {{ Concat r = new Concat(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            <OP_PIPE>     right=MulChain() {{ BitwiseOr r = new BitwiseOr(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            "&"           right=MulChain() {{ BitwiseAnd r = new BitwiseAnd(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            <OP_LSHIFT>   right=MulChain() {{ BitwiseLeftShift r = new BitwiseLeftShift(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
            |
            <OP_RSHIFT>   right=MulChain() {{ BitwiseRightShift r = new BitwiseRightShift(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
        )
    )*
    { return retval; }
}

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

Expression PrimaryExpression() #PrimaryExpression:
{
    Expression retval = null;
    Expression expression = 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;

    final List<Map.Entry<Expression, String>> jsonIdents = new ArrayList<Map.Entry<Expression, String>>();
}
{
    [ <K_NOT> { not=true; } | "!" { not=true; exclamationMarkNot=true; } ]
    [sign="+" | sign="-" | sign="~"]
    (
        <K_NULL> { retval = new NullValue(); }

        | LOOKAHEAD({!interrupted && isCaseExpressionAhead()}) retval=CaseWhenExpression()

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

        | LOOKAHEAD({!interrupted && isImplicitCastAhead()}) retval=ImplicitCast()

        | retval = JdbcParameter()

        | LOOKAHEAD(2) retval =JdbcNamedParameter()

        | LOOKAHEAD(3) retval=UserVariable()

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

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

        | retval=XMLSerializeExpr()

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

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

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

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

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

        | LOOKAHEAD(2) retval = DateUnitExpression()

        | 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(3) retval=AllColumns(true)

        | LOOKAHEAD({ !interrupted && isAllTableColumnsAhead() })
                  retval=AllTableColumns(true)

        // See issue  #2207
        // there is a huge! performance deterioration from this production
        //| LOOKAHEAD(FunctionAllColumns()) retval=FunctionAllColumns()

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

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

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

        | LOOKAHEAD(3, {!interrupted}) <K_ARRAY_LITERAL> [ "<" type=ColDataType() ">" ] retval=ArrayConstructor(true) { if (type!=null) ((ArrayConstructor) retval).setDataType(type); }

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

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

        | retval=ConnectByRootOperator()

        | retval=ConnectByPriorOperator()

        | LOOKAHEAD(2, { !interrupted && getToken(1).kind == K_KEY && getToken(2).kind != OPENING_BRACKET }) retval=KeyExpression()

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

        | LOOKAHEAD(2, {!interrupted}) retval=Column()
            [
                LOOKAHEAD( "(" "+" ")" ("," | ")") )
                "(" "+" ")" { ((Column) retval).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); }
            ]

        | LOOKAHEAD(2, {!interrupted}) (token=<K_TRUE> | token=<K_FALSE>) { retval = new BooleanValue(token.image); }

        | 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({ getAsBoolean(Feature.allowUnparenthesizedSubSelects) && !interrupted
                && (getToken(1).kind == K_SELECT || getToken(1).kind == K_WITH || getToken(1).kind == K_VALUES
                    || (getToken(1).kind == OPENING_BRACKET && (getToken(2).kind == K_SELECT || getToken(2).kind == K_WITH || getToken(2).kind == K_VALUES))) }) retval=Select()

        | LOOKAHEAD({ !getAsBoolean(Feature.allowUnparenthesizedSubSelects) && !interrupted && isParenthesedSelectAhead() }) retval=ParenthesedSelect()

        | LOOKAHEAD({ !interrupted && isNestedSetOperationAhead() }) retval=ParenthesedSelect()

        |
        (
            list=ParenthesedExpressionList()
             // Mutli-Variable Lambda Expression, e. g.
            // SELECT map_filter(my_column, (k,v) -> v.my_inner_column = 'some_value')
            // First-arg form (issue #2195): array_map((x,y,z) -> x + y, ...)
            (
                LOOKAHEAD(2) "->"
                      retval = Expression()
                      {
                          retval = LambdaExpression.from(list, retval);
                      }
                |
                {
                    if (list.size() == 1) {
                        retval = new ParenthesedExpressionList( (Expression) list.getExpressions().get(0));
                    } else {
                        retval = list;
                    }
                }
            )

            // PostgreSQL composite row expansion: (function()).*
            // Re-enables FunctionAllColumns, which was disabled in #2207 due to the
            // performance toll of a speculative syntactic lookahead. A bounded
            // semantic follower check instead reads the already-parsed retval and
            // peeks the next two tokens, avoiding any speculative production.
            [ LOOKAHEAD( { isFunctionAllColumnsAhead(retval) } )
                "." "*"
                { retval = new FunctionAllColumns(unwrapParenthesedFunction(retval)); } ]

            // RowGet Expressions
            ( LOOKAHEAD(2) "." tmp=RelObjectName() { retval = new RowGetExpression(retval, tmp); } )*
        )
    )

    [
        LOOKAHEAD(2) <K_COLLATE> (token=<S_CHAR_LITERAL> | token=<S_QUOTED_IDENTIFIER> | token=<S_IDENTIFIER>) { retval = new CollateExpression(retval, token.image); }
    ]

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

    [ LOOKAHEAD(2) retval = ArrayExpression(retval) ]

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

    // Check for JSON operands
    [
        LOOKAHEAD(2, { ternaryThenBranchDepth == 0 || !":".equals(getToken(1).image) }) (
            LOOKAHEAD(2) (
                token="->"
                |
                token=":"
                |
                token="->>"
                |
                token="#>"
                |
                token="#>>"
            )

            (
                LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted }) expression=Expression()
                |
                expression=SimpleExpression()
            )
            {
                jsonIdents.add(new AbstractMap.SimpleEntry<Expression, String>(expression, token.image ));
            }
        )+
        retval = JsonExpression(retval, jsonIdents)
    ]

    ( 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);
        }
        linkAST(retval, jjtThis);
        return retval;
    }
}

/* https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/hierarchical_query_clause.html

    { CONNECT BY [ NOCYCLE ] condition [ START WITH condition ]
    | START WITH condition CONNECT BY [ NOCYCLE ] condition
    }
 */

ConnectByRootOperator ConnectByRootOperator() #ConnectByRootOperator: {
    Expression expression;
}
{
    <K_CONNECT_BY_ROOT> expression = Expression()
    {
      return new ConnectByRootOperator(expression);
    }
}

ConnectByPriorOperator ConnectByPriorOperator() #ConnectByPriorOperator: {
    Expression expression;
}
{
    <K_PRIOR> expression = Expression()
    {
        return new ConnectByPriorOperator(expression);
    }
}

KeyExpression KeyExpression() #KeyExpression: {
    Expression expression;
}
{
    <K_KEY> expression = Expression()
    {
        return new KeyExpression(expression);
    }
}


NextValExpression NextValExpression() : {
    ObjectNames data = null;
    Token token;
}
{
     token=<K_NEXTVAL>  data = RelObjectNames()
    {
        return new NextValExpression(data.getNames(), token.image);
    }
}

JdbcNamedParameter JdbcNamedParameter() : {
    JdbcNamedParameter parameter = new JdbcNamedParameter();
    String name;
    String namePart;
}
{
    (":" | "&" { parameter.setParameterCharacter("&"); } )
    name=IdentifierChain()
    {
        parameter.setName(name);
        return parameter;
    }
}

OracleNamedFunctionParameter OracleNamedFunctionParameter() : {
    Token token = null;
    String name = null;
    Expression expression;
}
{
    ( name=RelObjectNameExt() | token=<K_OUTER> )
    <K_ORACLE_NAMED_PARAMETER_ASSIGNMENT>
    expression=Expression()
    {
        return new OracleNamedFunctionParameter(name != null ? name : token.image, expression);
    }
}

PostgresNamedFunctionParameter PostgresNamedFunctionParameter() : {
    Token token = null;
    String name = null;
    Expression expression;
}
{
    ( name=RelObjectNameExt() | token=<K_OUTER> )
    <K_POSTGRES_NAMED_PARAMETER_ASSIGNMENT>
    expression=Expression()
    {
        return new PostgresNamedFunctionParameter(name != null ? name : token.image, expression);
    }
}

UserVariable UserVariable() : {
    Token tk;
    String varName;
}
{
    tk = <S_AT_IDENTIFIER> varName=IdentifierChain2(tk.image)
    {
        return new UserVariable(varName);
    }
}

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.from(t.image));
    }

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

DateUnitExpression DateUnitExpression() : {
    Token t;
}
{
    t=<K_DATE_LITERAL>  { return new DateUnitExpression( t.image ); }
}

RangeExpression RangeExpression(Expression startExpression):
{
    Expression endExpression;
}
{
    ":" endExpression = Expression()
    {
        return new RangeExpression(startExpression, endExpression);
    }
}

ArrayConstructor ArrayConstructor(boolean arrayKeyword) : {
    ExpressionList expList = new ExpressionList();
    ArrayConstructor array = new ArrayConstructor(expList, arrayKeyword);
    Expression exp;
} {
    "["
    [
        (
            LOOKAHEAD(3) exp = Expression() [ exp=RangeExpression(exp) ]
            |
            exp = ArrayConstructor(false)
        ) { expList.add(exp); }

        (
            ","
            (
                LOOKAHEAD(3) exp = Expression() [ exp=RangeExpression(exp) ]
                |
                exp = ArrayConstructor(false)
            ){ expList.add(exp); }
        )*
    ]
    "]"
    { return array; }
}

List<Map.Entry<String, ColDataType>> StructParameters():
{
    String parameterName = "";
    ColDataType parameterType = null;
    AbstractMap.SimpleEntry<String, ColDataType> parameter = null;
    List<Map.Entry<String, ColDataType>> parameters = new ArrayList<Map.Entry<String, ColDataType>>();
}
{
    [ LOOKAHEAD(2) parameterName = RelObjectName() ]
    parameterType = ColDataType()
    {
        parameters.add( new AbstractMap.SimpleEntry<String, ColDataType>(parameterName, parameterType) );
    }

    (
        "," { parameterName=""; }

        [ LOOKAHEAD(2) parameterName = RelObjectName() ]
        parameterType = ColDataType()
        {
            parameters.add( new AbstractMap.SimpleEntry<String, ColDataType>(parameterName, parameterType) );
        }
    )*

    {
        return parameters;
    }
}

StructType StructType() #StruckType:
{
    StructType.Dialect dialect = StructType.Dialect.BIG_QUERY;
    Token tk1;
    String keyword = "";
    List<Map.Entry<String, ColDataType>> parameters = null;
    List<SelectItem<?>> arguments = null;
    String id = null;
    Expression expression = null;
    StructType type;
}
{
    (
        LOOKAHEAD(4) (
            tk1=<K_STRUCT> { keyword = tk1.image; }
            "<" parameters = StructParameters() ">"
            "(" arguments = SelectItemsList() ")"
        )
        |
        (
            tk1=<K_STRUCT> { keyword = tk1.image; }
            "(" arguments = SelectItemsList() ")"
        )
        |
        (
            <OPENING_CURLY_BRACKET> { arguments= new  ArrayList<SelectItem<?>>(); dialect = StructType.Dialect.DUCKDB;}
            ( id = RelObjectNameExt() | tk1=<S_CHAR_LITERAL> { id = tk1.image; } )
            <DOUBLE_COLON> expression = Expression() { arguments.add( new SelectItem( expression, id) ); }

            (
                ","
                ( id = RelObjectNameExt() | tk1=<S_CHAR_LITERAL> { id = tk1.image; } )
                <DOUBLE_COLON> expression = Expression() { arguments.add( new SelectItem( expression, id) ); }
            )*
            <CLOSING_CURLY_BRACKET>

            (
                LOOKAHEAD(2) "::" <K_STRUCT> "(" parameters = StructParameters() ")"
            )*
        )
    )
    {
        type = new StructType(dialect, keyword, parameters, arguments);
        linkAST(type,jjtThis);
        return type;
    }
}

JsonExpression JsonExpression(Expression expr, List<Map.Entry<Expression, String>> idents) : {
  JsonExpression result = new JsonExpression(expr, idents);
  Expression expression;
  Token token=null;
  ColDataType type = null;
  CastExpression castExpr = null;
}
{

    // chaining JSON Expressions, e.g.
    // '{"obj":{"field": "value"}}'::JSON -> 'obj'::TEXT ->> 'field'::TEXT
    (
        LOOKAHEAD(2, {!interrupted} ) (
            LOOKAHEAD(2) (
                "::" type=ColDataType()
                {
                    castExpr = new CastExpression();
                    castExpr.setUseCastKeyword(false);
                    castExpr.setLeftExpression(result);
                    castExpr.setColDataType(type);
                    expr=castExpr;
                }
            )
        )+
        {
            result = new JsonExpression(expr);
        }

        (
            LOOKAHEAD(2, { ternaryThenBranchDepth == 0 || !":".equals(getToken(1).image) }) (
                token="->"
                |
                token=":"
                |
                token="->>"
                |
                token="#>"
                |
                token="#>>"
            )

            (
                LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) expression=Expression()
                |
                expression=SimpleExpression()
            )
            {
                result.addIdent( expression, token.image );
            }
        )*
    )*

    {
        result.setExpression(expr);
        return result;
    }
}

JsonKeyValuePair JsonKeyValuePair(boolean isFirstEntry) : {
    Token keyToken;

    boolean usingKeyKeyword = false;
    boolean usingFormatJason = false;
    String encoding = null;
    boolean isWildcard = false;

    Object key = null;
    Expression expression = null;
    JsonFunctionExpression functionExpression;

    JsonKeyValuePairSeparator kvSeparator = JsonKeyValuePairSeparator.NOT_USED;
}
{
    (
        // lookahead because key is a valid column name
        LOOKAHEAD(2) (
            <K_KEY> { usingKeyKeyword = true; }
            (
               keyToken = <S_CHAR_LITERAL> { key = keyToken.image; } |
               key = Column()
            )
        )
        |
        LOOKAHEAD(16) key = AllTableColumns(false) { isWildcard = true; }
        |
        LOOKAHEAD(2) key = AllColumns(false) { isWildcard = true; }
        |
        LOOKAHEAD(2) key = Column()
        |
        LOOKAHEAD({getAsBoolean(Feature.allowExpressionAsJsonObjectKey)}) key = Expression()
        |
        keyToken = <S_CHAR_LITERAL> { key = keyToken.image; }
    )

    // Optional Separator + Value - Is not allowed with * or t1.*
    [ LOOKAHEAD(1, { !isWildcard } )
       (
           <K_VALUE> { kvSeparator = JsonKeyValuePairSeparator.VALUE; }
           |
           <DOUBLE_COLON> { kvSeparator = JsonKeyValuePairSeparator.COLON; }
           |
           LOOKAHEAD({getAsBoolean(Feature.allowCommaAsKeyValueSeparator)}) <K_COMMA> { kvSeparator = JsonKeyValuePairSeparator.COMMA; }
       )
       expression = Expression()
    ]

    // Optional: FORMAT JSON [ ENCODING ... ] - Is not allowed with * or t1.*
    [
        LOOKAHEAD(1, { !isWildcard } ) <K_FORMAT> <K_JSON> { usingFormatJason = true; }
        [ <K_ENCODING> encoding = JsonEncoding() ]
    ]
    {
        final JsonKeyValuePair keyValuePair = new JsonKeyValuePair( key, expression, usingKeyKeyword, kvSeparator );
        keyValuePair.setUsingFormatJson( usingFormatJason );
        keyValuePair.setEncoding(encoding);
        return keyValuePair;
   }
}

JsonFunction JsonObjectBody() : {
    JsonFunction result = new JsonFunction(JsonFunctionType.OBJECT);

    JsonKeyValuePair keyValuePair;
    ColDataType dataType;
    String encoding;
}
{
    ( "("
        (
            // First Element
            LOOKAHEAD(2) keyValuePair = JsonKeyValuePair(true) { result.add(keyValuePair);}

            // Next Elements
            (
                <K_COMMA>  keyValuePair = JsonKeyValuePair(false) { result.add(keyValuePair); }
            )*
        )?
        [
          ( <K_NULL> <K_ON> <K_NULL>  { result.setOnNullType(  JsonAggregateOnNullType.NULL ); } )
          |
          ( <K_ABSENT> <K_ON> <K_NULL> { result.setOnNullType(  JsonAggregateOnNullType.ABSENT ); } )
        ]
        [ <K_STRICT> { result.setStrict(true); } ]
        [
          ( <K_WITH> <K_UNIQUE> <K_KEYS> { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITH ); } )
          |
          ( <K_WITHOUT> <K_UNIQUE> <K_KEYS> { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITHOUT ); } )
        ]
        [
            <K_RETURNING> dataType = ColDataType() { result.setReturningType(dataType); }
            [
                <K_FORMAT> <K_JSON> { result.setReturningFormatJson(true); }
                [ <K_ENCODING> encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ]
            ]
        ]
    ")" )
    {
        return result;
    }
}

JsonFunction JsonArrayBody() : {
    JsonFunction result = new JsonFunction(JsonFunctionType.ARRAY);

    Expression expression = null;
    JsonFunctionExpression functionExpression;
    ColDataType dataType;
    String encoding;
}
{
    ( "("
        (
            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 ); }
                [ LOOKAHEAD(2) <K_ENCODING> encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ]
            ]
            (
                ","
                expression=Expression() { functionExpression = new JsonFunctionExpression( expression ); result.add( functionExpression ); }
                [
                    LOOKAHEAD(2) <K_FORMAT> <K_JSON> { functionExpression.setUsingFormatJson( true ); }
                    [ LOOKAHEAD(2) <K_ENCODING> encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ]
                ]
            )*
        )*

        [
          <K_ABSENT> <K_ON> <K_NULL> { result.setOnNullType(  JsonAggregateOnNullType.ABSENT ); }
        ]
        [
            <K_RETURNING> dataType = ColDataType() { result.setReturningType(dataType); }
            [
                <K_FORMAT> <K_JSON> { result.setReturningFormatJson(true); }
                [ <K_ENCODING> encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ]
            ]
        ]
    ")" )
    {
        return result;
    }
}

void JsonKeyword(String expectedKeyword) : {
    Token token;
}
{
    token = <S_IDENTIFIER>
    {
        if (!token.image.equalsIgnoreCase(expectedKeyword)) {
            throw new ParseException(
                    "Expected keyword " + expectedKeyword + " but found " + token.image);
        }
    }
}

String JsonEncoding() : {
    Token token;
}
{
    token = <S_IDENTIFIER>
    {
        if (token.image.equalsIgnoreCase("UTF8")) {
            return "UTF8";
        } else if (token.image.equalsIgnoreCase("UTF16")) {
            return "UTF16";
        } else if (token.image.equalsIgnoreCase("UTF32")) {
            return "UTF32";
        }
        throw new ParseException(
                "Expected ENCODING value UTF8, UTF16 or UTF32 but found " + token.image);
    }
}

JsonFunctionExpression JsonValueOrQueryInputExpression() : {
    Expression expression;
    JsonFunctionExpression functionExpression;
    String encoding;
}
{
    expression = Expression() { functionExpression = new JsonFunctionExpression(expression); }
    [
        <K_FORMAT> <K_JSON> { functionExpression.setUsingFormatJson(true); }
        [ <K_ENCODING> encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ]
    ]
    {
        return functionExpression;
    }
}

JsonFunction.JsonOnResponseBehavior JsonValueOnResponseBehavior() : {
    JsonFunction.JsonOnResponseBehavior behavior;
    Expression expression;
}
{
    (
        <K_ERROR>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.ERROR);
        }
        |
        <K_NULL>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.NULL);
        }
        |
        <K_EMPTY>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.EMPTY);
        }
        |
        <K_DEFAULT> expression = Expression()
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.DEFAULT, expression);
        }
    )
    {
        return behavior;
    }
}

JsonFunction.JsonOnResponseBehavior JsonQueryOnResponseBehavior() : {
    JsonFunction.JsonOnResponseBehavior behavior = null;
    Token token;
}
{
    (
        <K_ERROR>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.ERROR);
        }
        |
        <K_NULL>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.NULL);
        }
        |
        <K_TRUE>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.TRUE);
        }
        |
        <K_FALSE>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.FALSE);
        }
        |
        <K_EMPTY>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.EMPTY);
        }
        [
            (
                <K_ARRAY_LITERAL>
                {
                    behavior = new JsonFunction.JsonOnResponseBehavior(
                            JsonFunction.JsonOnResponseBehaviorType.EMPTY_ARRAY);
                }
                |
                JsonKeyword("OBJECT")
                {
                    behavior = new JsonFunction.JsonOnResponseBehavior(
                            JsonFunction.JsonOnResponseBehaviorType.EMPTY_OBJECT);
                }
            )
        ]
    )
    {
        return behavior;
    }
}

JsonFunction.JsonOnResponseBehavior JsonExistsOnResponseBehavior() : {
    JsonFunction.JsonOnResponseBehavior behavior = null;
}
{
    (
        <K_TRUE>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.TRUE);
        }
        |
        <K_FALSE>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.FALSE);
        }
        |
        <K_UNKNOWN>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.UNKNOWN);
        }
        |
        <K_ERROR>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.ERROR);
        }
    )
    {
        return behavior;
    }
}

JsonFunction JsonExistsBody() : {
    JsonFunction result = new JsonFunction(JsonFunctionType.EXISTS);
    JsonFunctionExpression inputExpression;
    Expression expression;
    JsonFunction.JsonOnResponseBehavior behavior;
}
{
    "("
    inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); }
    ","
    expression = Expression() { result.setJsonPathExpression(expression); }

    [
        LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") })
        JsonKeyword("PASSING")
        expression = Expression() { result.addPassingExpression(expression); }
        ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )*
    ]

    [
        LOOKAHEAD( JsonExistsOnResponseBehavior() <K_ON> <K_ERROR> )
        behavior = JsonExistsOnResponseBehavior()
        <K_ON> <K_ERROR>
        { result.setOnErrorBehavior(behavior); }
    ]
    ")"
    {
        return result;
    }
}

JsonFunction JsonValueBody() : {
    JsonFunction result = new JsonFunction(JsonFunctionType.VALUE);
    JsonFunctionExpression inputExpression;
    Expression expression;
    ColDataType dataType;
    JsonFunction.JsonOnResponseBehavior behavior;
}
{
    "("
    inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); }
    ","
    expression = Expression() { result.setJsonPathExpression(expression); }

    [
        LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") })
        JsonKeyword("PASSING")
        expression = Expression() { result.addPassingExpression(expression); }
        ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )*
    ]

    [ <K_RETURNING> dataType = ColDataType() { result.setReturningType(dataType); } ]

    [
        LOOKAHEAD( JsonValueOnResponseBehavior() <K_ON> <K_EMPTY> )
        behavior = JsonValueOnResponseBehavior()
        <K_ON> <K_EMPTY>
        { result.setOnEmptyBehavior(behavior); }
    ]

    [
        LOOKAHEAD( JsonValueOnResponseBehavior() <K_ON> <K_ERROR> )
        behavior = JsonValueOnResponseBehavior()
        <K_ON> <K_ERROR>
        { result.setOnErrorBehavior(behavior); }
    ]
    ")"
    {
        return result;
    }
}

JsonFunction JsonQueryBody() : {
    JsonFunction result = new JsonFunction(JsonFunctionType.QUERY);
    JsonFunctionExpression inputExpression;
    Expression expression;
    ColDataType dataType;
    JsonFunction.JsonOnResponseBehavior behavior;
    Token token;
    String encoding;
    ColDataType additionalReturningType;
    boolean additionalReturningFormatJson;
    String additionalReturningEncoding;
    JsonFunction.JsonWrapperType additionalWrapperType;
    JsonFunction.JsonWrapperMode additionalWrapperMode;
    boolean additionalWrapperArray;
    JsonFunction.JsonQuotesType additionalQuotesType;
    boolean additionalQuotesOnScalarString;
    JsonFunction.JsonOnResponseBehavior additionalOnEmptyBehavior;
    JsonFunction.JsonOnResponseBehavior additionalOnErrorBehavior;
    StringBuilder additionalBuilder;
    boolean hasPassingClause = false;
}
{
    "("
    inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); }
    ","
    expression = Expression() { result.setJsonPathExpression(expression); }

    [
        LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") })
        JsonKeyword("PASSING") { hasPassingClause = true; }
        expression = Expression() { result.addPassingExpression(expression); }
        ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )*
    ]

    [
        <K_RETURNING> dataType = ColDataType() { result.setReturningType(dataType); }
        [
            <K_FORMAT> <K_JSON> { result.setReturningFormatJson(true); }
            [ <K_ENCODING> encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ]
        ]
    ]

    [
        (
            <K_WITHOUT> { result.setWrapperType(JsonFunction.JsonWrapperType.WITHOUT); }
            [ <K_ARRAY_LITERAL> { result.setWrapperArray(true); } ]
            JsonKeyword("WRAPPER")
            |
            <K_WITH> { result.setWrapperType(JsonFunction.JsonWrapperType.WITH); }
            [
                LOOKAHEAD({
                    getToken(1).kind == S_IDENTIFIER
                        && (getToken(1).image.equalsIgnoreCase("CONDITIONAL")
                            || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL"))
                })
                token = <S_IDENTIFIER>
                {
                    if (token.image.equalsIgnoreCase("CONDITIONAL")) {
                        result.setWrapperMode(JsonFunction.JsonWrapperMode.CONDITIONAL);
                    } else {
                        result.setWrapperMode(JsonFunction.JsonWrapperMode.UNCONDITIONAL);
                    }
                }
            ]
            [ <K_ARRAY_LITERAL> { result.setWrapperArray(true); } ]
            JsonKeyword("WRAPPER")
        )
    ]

    [
        LOOKAHEAD({
            getToken(1).kind == K_KEEP
                || (getToken(1).kind == S_IDENTIFIER
                    && getToken(1).image.equalsIgnoreCase("OMIT"))
        })
        (
            <K_KEEP> { result.setQuotesType(JsonFunction.JsonQuotesType.KEEP); }
            |
            JsonKeyword("OMIT") { result.setQuotesType(JsonFunction.JsonQuotesType.OMIT); }
        )
        JsonKeyword("QUOTES")
        [
            <K_ON> JsonKeyword("SCALAR") <K_STRING>
            { result.setQuotesOnScalarString(true); }
        ]
    ]

    [
        LOOKAHEAD( JsonQueryOnResponseBehavior() <K_ON> <K_EMPTY> )
        behavior = JsonQueryOnResponseBehavior()
        <K_ON> <K_EMPTY>
        { result.setOnEmptyBehavior(behavior); }
    ]

    [
        LOOKAHEAD( JsonQueryOnResponseBehavior() <K_ON> <K_ERROR> )
        behavior = JsonQueryOnResponseBehavior()
        <K_ON> <K_ERROR>
        { result.setOnErrorBehavior(behavior); }
    ]

    (
        LOOKAHEAD(2, { !hasPassingClause })
        ","
        {
            additionalReturningType = null;
            additionalReturningFormatJson = false;
            additionalReturningEncoding = null;
            additionalWrapperType = null;
            additionalWrapperMode = null;
            additionalWrapperArray = false;
            additionalQuotesType = null;
            additionalQuotesOnScalarString = false;
            additionalOnEmptyBehavior = null;
            additionalOnErrorBehavior = null;
        }
        expression = Expression()
        [
            <K_RETURNING> additionalReturningType = ColDataType()
            [
                <K_FORMAT> <K_JSON> { additionalReturningFormatJson = true; }
                [ <K_ENCODING> additionalReturningEncoding = JsonEncoding() ]
            ]
        ]
        [
            (
                <K_WITHOUT>
                { additionalWrapperType = JsonFunction.JsonWrapperType.WITHOUT; }
                [ <K_ARRAY_LITERAL> { additionalWrapperArray = true; } ]
                JsonKeyword("WRAPPER")
                |
                <K_WITH>
                { additionalWrapperType = JsonFunction.JsonWrapperType.WITH; }
                [
                    LOOKAHEAD({
                        getToken(1).kind == S_IDENTIFIER
                            && (getToken(1).image.equalsIgnoreCase("CONDITIONAL")
                                || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL"))
                    })
                    token = <S_IDENTIFIER>
                    {
                        if (token.image.equalsIgnoreCase("CONDITIONAL")) {
                            additionalWrapperMode = JsonFunction.JsonWrapperMode.CONDITIONAL;
                        } else {
                            additionalWrapperMode = JsonFunction.JsonWrapperMode.UNCONDITIONAL;
                        }
                    }
                ]
                [ <K_ARRAY_LITERAL> { additionalWrapperArray = true; } ]
                JsonKeyword("WRAPPER")
            )
        ]
        [
            LOOKAHEAD({
                getToken(1).kind == K_KEEP
                    || (getToken(1).kind == S_IDENTIFIER
                        && getToken(1).image.equalsIgnoreCase("OMIT"))
            })
            (
                <K_KEEP> { additionalQuotesType = JsonFunction.JsonQuotesType.KEEP; }
                |
                JsonKeyword("OMIT") { additionalQuotesType = JsonFunction.JsonQuotesType.OMIT; }
            )
            JsonKeyword("QUOTES")
            [
                <K_ON> JsonKeyword("SCALAR") <K_STRING> { additionalQuotesOnScalarString = true; }
            ]
        ]
        [
            LOOKAHEAD( JsonQueryOnResponseBehavior() <K_ON> <K_EMPTY> )
            additionalOnEmptyBehavior = JsonQueryOnResponseBehavior()
            <K_ON> <K_EMPTY>
        ]
        [
            LOOKAHEAD( JsonQueryOnResponseBehavior() <K_ON> <K_ERROR> )
            additionalOnErrorBehavior = JsonQueryOnResponseBehavior()
            <K_ON> <K_ERROR>
        ]
        {
            additionalBuilder = new StringBuilder();
            additionalBuilder.append(expression);
            if (additionalReturningType != null) {
                additionalBuilder.append(" RETURNING ").append(additionalReturningType);
                if (additionalReturningFormatJson) {
                    additionalBuilder.append(" FORMAT JSON");
                    if (additionalReturningEncoding != null) {
                        additionalBuilder.append(" ENCODING ").append(additionalReturningEncoding);
                    }
                }
            }
            if (additionalWrapperType != null) {
                additionalBuilder.append(" ").append(additionalWrapperType);
                if (additionalWrapperMode != null) {
                    additionalBuilder.append(" ").append(additionalWrapperMode);
                }
                if (additionalWrapperArray) {
                    additionalBuilder.append(" ARRAY");
                }
                additionalBuilder.append(" WRAPPER");
            }
            if (additionalQuotesType != null) {
                additionalBuilder.append(" ").append(additionalQuotesType).append(" QUOTES");
                if (additionalQuotesOnScalarString) {
                    additionalBuilder.append(" ON SCALAR STRING");
                }
            }
            if (additionalOnEmptyBehavior != null) {
                additionalBuilder.append(" ").append(additionalOnEmptyBehavior).append(" ON EMPTY");
            }
            if (additionalOnErrorBehavior != null) {
                additionalBuilder.append(" ").append(additionalOnErrorBehavior).append(" ON ERROR");
            }
            result.addAdditionalQueryPathArgument(additionalBuilder.toString());
        }
    )*
    ")"
    {
        return result;
    }
}

JsonFunction JsonFunction() : {
    JsonFunction result;
}
{
    (
      ( <K_JSON_OBJECT> result = JsonObjectBody() )
      |
      ( <K_JSON_ARRAY> result = JsonArrayBody() )
      |
      (
          LOOKAHEAD({
              getToken(1).kind == S_IDENTIFIER
                  && getToken(1).image.equalsIgnoreCase("JSON_VALUE")
          })
          JsonKeyword("JSON_VALUE")
          result = JsonValueBody()
      )
      |
      (
          LOOKAHEAD({
              getToken(1).kind == S_IDENTIFIER
                  && getToken(1).image.equalsIgnoreCase("JSON_QUERY")
          })
          JsonKeyword("JSON_QUERY")
          result = JsonQueryBody()
      )
      |
      (
          LOOKAHEAD({
              getToken(1).kind == S_IDENTIFIER
                  && getToken(1).image.equalsIgnoreCase("JSON_EXISTS")
          })
          JsonKeyword("JSON_EXISTS")
          result = JsonExistsBody()
      )
    )
    {
        return result;
    }
}

JsonAggregateFunction JsonAggregateFunction() : {
    JsonAggregateFunction result = new JsonAggregateFunction();
    Token token;
    Object key;
    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 ); }
            (
                LOOKAHEAD(2) (
                    "KEY" { result.setUsingKeyKeyword( true ); }
                    (
                        ( token = <DT_ZONE> | token = <S_DOUBLE> | token = <S_LONG> | token = <S_HEX> | token = <S_CHAR_LITERAL> )
                        {
                            key = token.image;
                        }
                        |
                        key = Column()
                    )
                )
                |
                ( token = <DT_ZONE> | token = <S_DOUBLE> | token = <S_LONG> | token = <S_HEX> | token = <S_CHAR_LITERAL> )
                {
                    key = token.image;
                }
                |
                key = Column()
            )
            {
                result.setKey( key );
            }

            ( ":" | ","  { result.setType( JsonFunctionType.MYSQL_OBJECT ); } | "VALUE" {result.setUsingValueKeyword( true ); } )
            expression = Expression() { result.setValue( expression ); }

            [ <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(3) 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 = new IntervalExpression();
    Token token = null;
    Expression expr = null;
    boolean signed = false;
    IntervalQualifier qualifier = null;
}
{

    <K_INTERVAL>
    (

        LOOKAHEAD(3) (
            [ "-" {signed=true;}]
            (token=<S_LONG> | token=<S_DOUBLE>)
        )
        |
        LOOKAHEAD(2) token=<S_CHAR_LITERAL>
        |
        expr = Expression()
    )
    {
        if (expr != null) {
            if (signed) expr = new SignedExpression('-', expr);
            interval.setExpression(expr);
        } else {
            interval.setParameter((signed?"-":"") + token.image);
        }
    }
    [
        // Standard qualifier (field [TO field] [(precision)]) such as DAY or DAY TO SECOND.
        LOOKAHEAD(2, { getToken(1).kind == K_DATE_LITERAL }) qualifier = IntervalQualifier() { interval.setIntervalQualifier(qualifier); }
        // Non-standard single identifier field (e.g. MySQL `INTERVAL 1 foo`), kept for
        // backwards compatibility.
        | LOOKAHEAD(2) (token = <S_IDENTIFIER>) { interval.setIntervalType(token.image); }
    ]
    {
        return interval;
    }
}

IntervalExpression IntervalExpressionWithoutInterval(Expression expr) : {
    IntervalExpression interval;
    IntervalQualifier qualifier = null;
    boolean signed = false;
}
{
    {
        interval = new IntervalExpression(false);
        interval.setExpression(expr);
    }
    qualifier = IntervalQualifier()
    {
        interval.setIntervalQualifier(qualifier);
        return interval;
    }
}

/**
 * Parses an SQL interval qualifier, e.g. {@code DAY}, {@code DAY TO SECOND},
 * {@code DAY(9) TO SECOND} or {@code SECOND(2, 4)}, as defined by the SQL standard.
 * Shared by {@link IntervalExpression} (DML interval literals) and by {@code ColDataType}
 * (DDL {@code INTERVAL} column / cast target types).
 */
IntervalQualifier IntervalQualifier() : {
    Token field = null;
    Token toField = null;
    Token leadingPrecision = null;
    Token fractionalPrecision = null;
    Token trailingFractionalPrecision = null;
}
{
    field = <K_DATE_LITERAL>
    [
        LOOKAHEAD(2) "(" leadingPrecision = <S_LONG>
        [ "," fractionalPrecision = <S_LONG> ]
        ")"
    ]
    [
        LOOKAHEAD(2) <K_TO> toField = <K_DATE_LITERAL>
        [ LOOKAHEAD(2) "(" trailingFractionalPrecision = <S_LONG> ")" ]
    ]
    {
        // SECOND(2, 4) TO SECOND(3) specifies fractional seconds precision for both the leading
        // and the trailing field. Reject such contradictory input instead of silently dropping one
        // of the values. The rejection is placed last so the production does not complete normally
        // and JavaCC does not append an unreachable "missing return" guard.
        if (fractionalPrecision == null || trailingFractionalPrecision == null) {
            return new IntervalQualifier(
                    field != null ? field.image : null,
                    leadingPrecision != null ? Integer.valueOf(leadingPrecision.image) : null,
                    toField != null ? toField.image : null,
                    trailingFractionalPrecision != null
                            ? Integer.valueOf(trailingFractionalPrecision.image)
                            : (fractionalPrecision != null
                                    ? Integer.valueOf(fractionalPrecision.image) : null));
        }
        throw new ParseException(
                "Invalid interval qualifier: fractional seconds precision is specified for both"
                        + " the leading field and the trailing field");
    }
}

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):{
     ExpressionList expressionList = null;
     boolean partitionByBrackets = false;
     String windowName = null;
     WindowDefinition winDef;
} {
    (
        <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); }

        [
            LOOKAHEAD(2) <K_OVER> "("
            [   <K_PARTITION> <K_BY>
                    (LOOKAHEAD(3) expressionList=ComplexExpressionList()
                    | "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")" )
            ]
            ")" { winDef.setPartitionExpressionList(expressionList, partitionByBrackets); retval.setType(AnalyticType.WITHIN_GROUP_OVER); }
        ]
    )
}

WindowDefinition windowDefinition() : {
    ExpressionList expressionList = null;
    List<OrderByElement> olist = null;
    WindowElement windowElement = null;
    boolean partitionByBrackets = false;
    WindowDefinition winDef = new WindowDefinition();
} {
    "("
    [<K_PARTITION> <K_BY>
        (LOOKAHEAD(3) 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;
    WindowElement.Exclusion exclusion = null;
}
{
    (<K_ROWS> { windowElement.setType(WindowElement.Type.ROWS); }
     | <K_RANGE> { windowElement.setType(WindowElement.Type.RANGE); }
     | <K_GROUPS> { windowElement.setType(WindowElement.Type.GROUPS); })
    ( (
      <K_BETWEEN> { windowElement.setRange(range); }
      offset = WindowOffset() { range.setStart(offset); }
      <K_AND> offset = WindowOffset() { range.setEnd(offset); }
      )
    |
      offset = WindowOffset() { windowElement.setOffset(offset); }
    )
    [ exclusion = FrameExclusion() { windowElement.setExclusion(exclusion); } ]

    {
        return windowElement;
    }
}

WindowElement.Exclusion FrameExclusion():
{
    WindowElement.Exclusion exclusion = null;
}
{
    <K_EXCLUDE>
    (
        <K_CURRENT> <K_ROW>
        { exclusion = WindowElement.Exclusion.CURRENT_ROW; }
        |
        <K_GROUP>
        { exclusion = WindowElement.Exclusion.GROUP; }
        |
        LOOKAHEAD({
            getToken(1).kind == S_IDENTIFIER
                && getToken(1).image.equalsIgnoreCase("TIES")
        })
        <S_IDENTIFIER>
        { exclusion = WindowElement.Exclusion.TIES; }
        |
        <K_NO>
        LOOKAHEAD({
            getToken(1).kind == S_IDENTIFIER
                && getToken(1).image.equalsIgnoreCase("OTHERS")
        })
        <S_IDENTIFIER>
        { exclusion = WindowElement.Exclusion.NO_OTHERS; }
    )
    { return exclusion; }
}

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 ImplicitCast() #ImplicitCast:
{
    ColDataType colDataType;
    Token tk1;
    Token tk2;

    int precision = -1;
    int scale = -1;
}
{
    colDataType = DataType()
    (
        tk2 = <S_CHAR_LITERAL>
        |
        tk2 = <S_LONG>
        |
        tk2 = <S_DOUBLE>
    )
    {
        CastExpression castExpression = new CastExpression(colDataType, tk2.image);
        return castExpression;
    }
}

CastExpression CastExpression():
{
    Token keyword;
    CastExpression retval;
    ColumnDefinition columnDefinition;
    ColDataType type;
    Expression expression = null;
    boolean    useCastKeyword;
    Token formatCharLiteral;
}
{
    (
        keyword=<K_CAST>
        |
        keyword=<K_SAFE_CAST>
        |
        keyword=<K_TRY_CAST>
        |
        keyword=<K_INTERPRET>
    )
    {
        retval = new CastExpression(keyword.image);
    }
    "("
    expression=SimpleExpression()
    <K_AS> { retval.setUseCastKeyword(true); }
    (
        LOOKAHEAD(2) (
            <K_ROW>
            "("
            columnDefinition=ColumnDefinition() { retval.addColumnDefinition(columnDefinition); }
            ( "," columnDefinition=ColumnDefinition() { retval.addColumnDefinition(columnDefinition); } )*
            ")"
        )
        |
        type=ColDataType() { retval.setColDataType(type); }
    )

    // BigQuery FORMAT clause
    // https://cloud.google.com/bigquery/docs/reference/standard-sql/conversion_functions#cast_as_date
    [ <K_FORMAT> formatCharLiteral=<S_CHAR_LITERAL> { retval.setFormat(formatCharLiteral.image); } ]

    ")"

    {
        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++; }
    [ LOOKAHEAD(2) switchExp=Expression() ]
    ( clause=WhenThenSearchCondition() { whenClauses.add(clause); } )+
    [
        <K_ELSE>
        (
              LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) elseExp=Expression()
              | elseExp=SimpleExpression()
        )
    ]
    <K_END>  { caseCounter--; }
    {
        caseExp.setSwitchExpression(switchExp);
        caseExp.setWhenClauses(whenClauses);
        caseExp.setElseExpression(elseExp);
        return caseExp;
    }
}

WhenClause WhenThenSearchCondition():
{
    WhenClause whenThen = new WhenClause();
    Expression whenExp;
    Expression thenExp;
}
{
    <K_WHEN> whenExp=Expression()
    <K_THEN>
    (
        LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) thenExp=Expression()
        |
        thenExp=SimpleExpression()
    )
    {
       whenThen.setWhenExpression(whenExp);
       whenThen.setThenExpression(thenExp);
       return whenThen;
    }
}

RowConstructor RowConstructor(): {
    Token token;
    ParenthesedExpressionList expressions;
} {
    token=<K_ROW>
    expressions = ParenthesedExpressionList()
    {
        return new RowConstructor(token.image, expressions);
    }
}

/**
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(): {
    Token token;
    ObjectNames 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=RelObjectNames() { execute.setName(funcName.getNames()); }

    (
        LOOKAHEAD(2)  expressionList=ExpressionList() { execute.setExprList(expressionList); }
    )?

    {
        return execute;
    }
}

FullTextSearch FullTextSearch() : {
    Token searchModifier;
    Expression againstValue;
    FullTextSearch fs = new FullTextSearch();
    ExpressionList<Column> matchedColumns;
}
{
    <K_MATCH> "(" matchedColumns=ColumnList() ")" <K_AGAINST>
    "("
    againstValue=SimpleExpression() { fs.setAgainstValue(againstValue); }
    [
        (
            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;
    }
}

LambdaExpression LambdaExpression() #LambdaExpression:
{
    ExpressionList<Column> columns;
    String s;
    Expression expression;
    LambdaExpression lambdaExpression;
}
{
    (
        columns = ParenthesedColumnList()
        |
        s = RelObjectName() { columns = new ExpressionList<Column>(new Column(s)); }
    )

    "->"
    expression = Expression()
    {
        lambdaExpression = LambdaExpression.from(columns, expression);
        linkAST(lambdaExpression,jjtThis);
        return lambdaExpression;
    }
}

Function Function() #Function:
{
    Function function;
}
{
    (
        "{" <K_FN> function = InternalFunction(true) "}"
        | LOOKAHEAD(3) function = SpecialStringFunctionWithNamedParameters()
        | function = InternalFunction(false)
    )
    {
        linkAST(function,jjtThis);
        return function;
    }
}

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

        "("
        (
            LOOKAHEAD( { isNamedExprListAhead() } ) namedExpressionList = NamedExpressionListExprFirst()
            |
            expressionList=ExpressionList()
        )
        ")"

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

JAVACODE
List<Function.KeywordArgument> consumeKeywordArguments() {
    List<Function.KeywordArgument> args = null;
    while (isKeywordArgumentAhead()) {
        String name = getNextToken().image;
        ExpressionList exprList = SimpleExpressionList();
        if (args == null) {
            args = new ArrayList<Function.KeywordArgument>();
        }
        Expression value = exprList.size() == 1
                ? (Expression) exprList.get(0)
                : exprList;
        args.add(new Function.KeywordArgument(name, value));
    }
    return args;
}

Function InternalFunction(boolean escaped):
{
    Token prefixToken = null;
    Function retval = new Function();
    ObjectNames funcName;
    ExpressionList expressionList = null;
    ExpressionList chainedExpressionList = null;
    KeepExpression keep = null;
    Expression expr = null;
    Expression attributeExpression = null;
    Column attributeColumn = null;
    Token attributeToken = null;
    Limit limit;
    List<Function.KeywordArgument> keywordArgs = null;
}
{
    [ LOOKAHEAD(2) prefixToken = <K_APPROXIMATE> ]
    funcName = RelObjectNames() { if (prefixToken!=null) funcName.getNames().add(0, prefixToken.image ); }

    "("
    [
        LOOKAHEAD(2) [
            LOOKAHEAD(2) (
                <K_DISTINCT> { retval.setDistinct(true); }
                | <K_ALL> { retval.setAllColumns(true); }
                | <K_UNIQUE> { retval.setUnique(true); }
            )
        ]
        (
            LOOKAHEAD(3) expressionList = FunctionArgumentList(retval)

            |
            // The probe above is syntactic and cannot see through the Pratt operator
            // loop, so it fails on arguments such as "( 1 + a ) / ( 1 + b )" and used
            // to fall through to Select(), reporting "Encountered <OPENING_BRACKET> ...
            // was expecting <K_WITH>". Select() is only reachable here for a bare
            // sub-select, so decide on that instead.
            LOOKAHEAD({ !isUnparenthesizedSelectAhead() }) expressionList = FunctionArgumentList(retval)

            |
            LOOKAHEAD({ !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) expr = Select() { expressionList = new ExpressionList(expr); }
        )
    ]

    [
        <K_HAVING> (
            <K_MIN> expr = Expression() { retval.setHavingClause( "MIN", expr ); }
            |
            <K_MAX> expr = Expression() { retval.setHavingClause( "MAX", expr ); }
        )
    ]

    [
        (
            <K_IGNORE> <K_NULLS> { retval.setNullHandling(Function.NullHandling.IGNORE_NULLS); }
        )
        |
        (
             <K_RESPECT> <K_NULLS> {  retval.setNullHandling(Function.NullHandling.RESPECT_NULLS); }
        )
    ]

    [
        limit = PlainLimit() { retval.setLimit(limit); }
    ]

    {
        keywordArgs = consumeKeywordArguments();
    }

    ")"

    [
        LOOKAHEAD(2) "(" chainedExpressionList = ExpressionList() ")"
    ]


    [
        LOOKAHEAD(2)
        (
            LOOKAHEAD({ getToken(1).kind == S_DOUBLE
                    && getToken(1).image.matches("\\.[0-9]+") })
            attributeToken=<S_DOUBLE> {
                retval.setAttribute(new LongValue(attributeToken.image.substring(1)));
            }
            |
            "." (
                    // tricky lookahead since we do need to support the following constructs
                    // schema.f1().f2() - Function with Function Column
                    // schema.f1().f2.f3 - Function with Attribute Column
                    LOOKAHEAD( 6 ) attributeExpression=Function() { retval.setAttribute(attributeExpression); }
                    |
                    attributeColumn=Column() { retval.setAttribute(attributeColumn); }
                )
        )
    ]

    [ LOOKAHEAD(2) (
            (
                <K_IGNORE> <K_NULLS>
                {
                    retval.setNullHandling(Function.NullHandling.IGNORE_NULLS);
                    retval.setIgnoreNullsOutside(true);
                }
            )
            |
            (
                 <K_RESPECT> <K_NULLS>
                 {
                    retval.setNullHandling(Function.NullHandling.RESPECT_NULLS);
                    retval.setIgnoreNullsOutside(true);
                 }
            )
        )
    ]

    [ LOOKAHEAD(2) keep = KeepExpression() ]

    {
        retval.setEscaped(escaped);
        retval.setParameters(expressionList);
        retval.setChainedParameters(chainedExpressionList);
        retval.setName(funcName.getNames());
        retval.setKeep(keep);
        retval.setKeywordArguments(keywordArgs);
        return retval;
    }
}

/**
 * Argument list of a Function, extracted from InternalFunction() so that it can be
 * reached from more than one lookahead guard without duplicating the expansion.
 */
ExpressionList FunctionArgumentList(Function retval):
{
    ExpressionList expressionList = null;
    List<OrderByElement> orderByList;
    String onOverflowTruncate = null;
    Token overflowToken = null;
    Token extraKeywordToken;
}
{
    [ LOOKAHEAD(2) extraKeywordToken = <K_TABLE> { retval.setExtraKeyword(extraKeywordToken.image); } ]
    expressionList=ExpressionList()
    [ orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } ]

    // https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/LISTAGG.html
    [
        <K_ON> <K_OVERFLOW> ( overflowToken=<K_TRUNCATE> | overflowToken=<K_ERROR> ) { onOverflowTruncate=overflowToken.image; }
        [
            overflowToken = <S_CHAR_LITERAL> { onOverflowTruncate+= " " + overflowToken.image; }
            [ ( overflowToken=<K_WITH> |  overflowToken=<K_WITHOUT> ) <K_COUNT> { onOverflowTruncate+=" " + overflowToken.image + " COUNT"; }]
        ]
    ] { retval.setOnOverflowTruncate(onOverflowTruncate); }

    {
        return expressionList;
    }
}

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;
    }
}


JsonTableFunction.JsonTablePassingClause JsonTablePassingClause() : {
    Expression valueExpression;
    String parameterName;
}
{
    valueExpression = Expression()
    <K_AS>
    parameterName = RelObjectName()
    {
        return new JsonTableFunction.JsonTablePassingClause(valueExpression, parameterName);
    }
}

JsonFunction.JsonOnResponseBehavior JsonTableOnEmptyBehavior() : {
    JsonFunction.JsonOnResponseBehavior behavior = null;
    Expression expression;
    Token token;
}
{
    (
        <K_ERROR>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.ERROR);
        }
        |
        <K_NULL>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.NULL);
        }
        |
        <K_TRUE>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.TRUE);
        }
        |
        <K_FALSE>
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.FALSE);
        }
        |
        <K_DEFAULT> expression = Expression()
        {
            behavior = new JsonFunction.JsonOnResponseBehavior(
                    JsonFunction.JsonOnResponseBehaviorType.DEFAULT, expression);
        }
        |
        token = <S_IDENTIFIER>
        {
            if (!token.image.equalsIgnoreCase("EMPTY")) {
                throw new ParseException(
                        "Expected EMPTY, ERROR, NULL or DEFAULT but found " + token.image);
            }
        }
        (
            LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("OBJECT") })
            JsonKeyword("OBJECT")
            {
                behavior = new JsonFunction.JsonOnResponseBehavior(
                        JsonFunction.JsonOnResponseBehaviorType.EMPTY_OBJECT);
            }
            |
            [ <K_ARRAY_LITERAL> ]
            {
                behavior = new JsonFunction.JsonOnResponseBehavior(
                        JsonFunction.JsonOnResponseBehaviorType.EMPTY_ARRAY);
            }
        )
    )
    {
        if (behavior != null) {
            return behavior;
        }
    }
}

JsonTableFunction.JsonTableWrapperClause JsonTableWrapperClause(boolean beforePathExpr) : {
    JsonTableFunction.JsonTableWrapperClause wrapperClause =
            new JsonTableFunction.JsonTableWrapperClause(beforePathExpr);
    Token token;
}
{
    (
        <K_WITHOUT> {
            wrapperClause.setWrapperType(JsonFunction.JsonWrapperType.WITHOUT);
        }
        |
        <K_WITH> {
            wrapperClause.setWrapperType(JsonFunction.JsonWrapperType.WITH);
        }
        [
            LOOKAHEAD({
                getToken(1).kind == S_IDENTIFIER
                    && (getToken(1).image.equalsIgnoreCase("CONDITIONAL")
                        || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL"))
            })
            token = <S_IDENTIFIER>
            {
                if (token.image.equalsIgnoreCase("CONDITIONAL")) {
                    wrapperClause.setWrapperMode(JsonFunction.JsonWrapperMode.CONDITIONAL);
                } else {
                    wrapperClause.setWrapperMode(JsonFunction.JsonWrapperMode.UNCONDITIONAL);
                }
            }
        ]
    )
    [ <K_ARRAY_LITERAL> { wrapperClause.setArray(true); } ]
    JsonKeyword("WRAPPER")
    {
        return wrapperClause;
    }
}

JsonTableFunction.JsonTableQuotesClause JsonTableQuotesClause() : {
    JsonTableFunction.JsonTableQuotesClause quotesClause =
            new JsonTableFunction.JsonTableQuotesClause();
}
{
    (
        <K_KEEP> { quotesClause.setQuotesType(JsonFunction.JsonQuotesType.KEEP); }
        |
        JsonKeyword("OMIT") { quotesClause.setQuotesType(JsonFunction.JsonQuotesType.OMIT); }
    )
    JsonKeyword("QUOTES")
    [
        <K_ON> JsonKeyword("SCALAR") <K_STRING> { quotesClause.setOnScalarString(true); }
    ]
    {
        return quotesClause;
    }
}

JsonTableFunction.JsonTableColumnDefinition JsonTableColumnDefinition() : {
    JsonTableFunction.JsonTableColumnDefinition columnDefinition = null;
    JsonTableFunction.JsonTableNestedColumnDefinition nestedColumnDefinition;
    JsonTableFunction.JsonTableValueColumnDefinition valueColumnDefinition;
    String columnName;
    ColDataType dataType;
    Expression expression;
    String pathName = null;
    JsonTableFunction.JsonTableColumnsClause columnsClause;
    JsonFunction.JsonOnResponseBehavior behavior;
    JsonTableFunction.JsonTableWrapperClause wrapperClause;
    JsonTableFunction.JsonTableQuotesClause quotesClause;
    String encoding;
}
{
    (
        LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("NESTED") })
        JsonKeyword("NESTED")
        { nestedColumnDefinition = new JsonTableFunction.JsonTableNestedColumnDefinition(); }
        [ LOOKAHEAD(2) <K_PATH> { nestedColumnDefinition.setPathKeyword(true); } ]
        expression = Expression() { nestedColumnDefinition.setPathExpression(expression); }
        [ <K_AS> pathName = RelObjectName() { nestedColumnDefinition.setPathName(pathName); } ]
        columnsClause = JsonTableColumnsClause() {
            nestedColumnDefinition.setColumnsClause(columnsClause);
            columnDefinition = nestedColumnDefinition;
        }
        |
        columnName = RelObjectName() {
            valueColumnDefinition = new JsonTableFunction.JsonTableValueColumnDefinition();
            valueColumnDefinition.setColumnName(columnName);
            columnDefinition = valueColumnDefinition;
        }
        (
            <K_FOR> <K_ORDINALITY> { valueColumnDefinition.setForOrdinality(true); }
            |
            [
                // Very ugly: ColDataType can consume an IDENTIFIER, which is fine, but we don't want it to
                // consume an ALLOW or DISALLOW because that's a keyword for Oracle in this place.
                // So we make a LOOKAHEAD on ColDataType, BUT we exclude the two cases for the IDENTIFIER

                /*
                [ ColDataType ]
                [ FORMAT JSON ]
                [ (ALLOW | DISALLOW) SCALARS ]
                 */

                LOOKAHEAD(
                    ColDataType(),
                        { !(getToken(1).kind == S_IDENTIFIER && (
                                getToken(1).image.equalsIgnoreCase("ALLOW")
                                || getToken(1).image.equalsIgnoreCase("DISALLOW"))) } )
                dataType = ColDataType() { valueColumnDefinition.setDataType(dataType); }
            ]
            [
                <K_FORMAT> <K_JSON> { valueColumnDefinition.setFormatJson(true); }
                [ <K_ENCODING> encoding = JsonEncoding() { valueColumnDefinition.setEncoding(encoding); } ]
            ]
            [
                (
                    LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("ALLOW") })
                            JsonKeyword("ALLOW") { valueColumnDefinition.setScalarsType(JsonFunction.ScalarsType.ALLOW); }
                    |
                    LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("DISALLOW") })
                            JsonKeyword("DISALLOW") { valueColumnDefinition.setScalarsType(JsonFunction.ScalarsType.DISALLOW); }
                )
                JsonKeyword("SCALARS")
            ]
            [ <K_EXISTS> { valueColumnDefinition.setExistsKeyword(true); } ]
            // In Oracle, the wrapper clause comes before the PATH expression
            [ LOOKAHEAD(2) wrapperClause = JsonTableWrapperClause(true) { valueColumnDefinition.setWrapperClause(wrapperClause); } ]
            [ <K_PATH> expression = Expression() { valueColumnDefinition.setPathExpression(expression); } ]
            // In Truno the wrapper clause comes after the PATH expression
            [ wrapperClause = JsonTableWrapperClause(false) { valueColumnDefinition.setWrapperClause(wrapperClause); } ]
            [
                LOOKAHEAD({
                    getToken(1).kind == K_KEEP
                        || (getToken(1).kind == S_IDENTIFIER
                            && getToken(1).image.equalsIgnoreCase("OMIT"))
                })
                quotesClause = JsonTableQuotesClause() { valueColumnDefinition.setQuotesClause(quotesClause); }
            ]
            [
                LOOKAHEAD( JsonTableOnEmptyBehavior() <K_ON> <K_EMPTY> )
                behavior = JsonTableOnEmptyBehavior()
                <K_ON> <K_EMPTY>
                { valueColumnDefinition.setOnEmptyBehavior(behavior); }
            ]
            [
                LOOKAHEAD( JsonQueryOnResponseBehavior() <K_ON> <K_ERROR> )
                behavior = JsonQueryOnResponseBehavior()
                <K_ON> <K_ERROR>
                { valueColumnDefinition.setOnErrorBehavior(behavior); }
            ]
            [
                LOOKAHEAD( JsonTableOnEmptyBehavior() <K_ON> <K_EMPTY> )
                behavior = JsonTableOnEmptyBehavior()
                <K_ON> <K_EMPTY>
                {
                    valueColumnDefinition.setOnEmptyBehavior(behavior);
                    valueColumnDefinition.setOnEmptyAfterOnError(true);
                }
            ]
        )
    )
    {
        return columnDefinition;
    }
}

JsonTableFunction.JsonTableColumnsClause JsonTableColumnsClause() : {
    JsonTableFunction.JsonTableColumnsClause columnsClause =
            new JsonTableFunction.JsonTableColumnsClause();
    JsonTableFunction.JsonTableColumnDefinition columnDefinition;
}
{
    <K_COLUMNS> "("
    [
        columnDefinition = JsonTableColumnDefinition() {
            columnsClause.addColumnDefinition(columnDefinition);
        }
        (
            ","
            columnDefinition = JsonTableColumnDefinition() {
                columnsClause.addColumnDefinition(columnDefinition);
            }
        )*
    ]
    ")"
    {
        return columnsClause;
    }
}

JsonTableFunction.JsonTablePlanTerm JsonTablePlanTerm() : {
    JsonTableFunction.JsonTablePlanTerm term = null;
    String value;
    Expression expression;
    JsonTableFunction.JsonTablePlanExpression nestedPlanExpression;
}
{
    (
        LOOKAHEAD(2)
        "(" nestedPlanExpression = JsonTablePlanExpression() ")" {
            term = new JsonTableFunction.JsonTablePlanTerm();
            term.setNestedPlanExpression(nestedPlanExpression);
        }
        |
        LOOKAHEAD(2)
        value = RelObjectName() {
            term = new JsonTableFunction.JsonTablePlanTerm();
            term.setName(value);
        }
        |
        expression = Expression() {
            term = new JsonTableFunction.JsonTablePlanTerm();
            term.setExpression(expression);
        }
    )
    {
        return term;
    }
}

JsonTableFunction.JsonTablePlanExpression JsonTablePlanExpression() : {
    JsonTableFunction.JsonTablePlanExpression planExpression =
            new JsonTableFunction.JsonTablePlanExpression();
    JsonTableFunction.JsonTablePlanTerm term;
    Token operator = null;
}
{
    term = JsonTablePlanTerm() { planExpression.addTerm(term); }
    (
        (
            operator = <K_COMMA> {
                planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.COMMA);
            }
            |
            operator = <K_INNER> {
                planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.INNER);
            }
            |
            operator = <K_OUTER> {
                planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.OUTER);
            }
            |
            operator = <K_CROSS> {
                planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.CROSS);
            }
            |
            operator = <K_UNION> {
                planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.UNION);
            }
        )
        term = JsonTablePlanTerm() { planExpression.addTerm(term); }
    )*
    {
        return planExpression;
    }
}

JsonTableFunction.JsonTablePlanClause JsonTablePlanClause() : {
    JsonTableFunction.JsonTablePlanClause planClause =
            new JsonTableFunction.JsonTablePlanClause();
    JsonTableFunction.JsonTablePlanExpression planExpression;
}
{
    <K_PLAN>
    [ <K_DEFAULT> { planClause.setDefaultPlan(true); } ]
    "(" planExpression = JsonTablePlanExpression() ")" { planClause.setPlanExpression(planExpression); }
    {
        return planClause;
    }
}

JsonTableFunction.JsonTableOnErrorClause JsonTableOnErrorClause(boolean beforeColumns) : {
    JsonTableFunction.JsonTableOnErrorClause onErrorClause =
            new JsonTableFunction.JsonTableOnErrorClause(beforeColumns);
    Token token;
}
{
    (
        <K_ERROR> { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.ERROR); }
        |
        <K_EMPTY> { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.EMPTY); }
        |
        <K_TRUE> { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.TRUE); }
        |
        <K_FALSE> { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.FALSE); }
        |
        <K_NULL> { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.NULL); }
    )
    <K_ON> <K_ERROR>
    {
        return onErrorClause;
    }
}

JsonTableFunction.JsonTableOnEmptyClause JsonTableOnEmptyClause() : {
    JsonTableFunction.JsonTableOnEmptyClause onEmptyClause =
            new JsonTableFunction.JsonTableOnEmptyClause();
    Token token;
}
{
    (
        <K_ERROR> { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.ERROR); }
        |
        <K_EMPTY> { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.EMPTY); }
        |
        <K_TRUE> { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.TRUE); }
        |
        <K_FALSE> { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.FALSE); }
        |
        <K_NULL> { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.NULL); }
    )
    <K_ON> <K_EMPTY>
    {
        return onEmptyClause;
    }
}

JsonTableFunction.JsonTableParsingTypeClause JsonTableParsingTypeClause() : {
    JsonTableFunction.JsonTableParsingTypeClause parsingType = new JsonTableFunction.JsonTableParsingTypeClause();
}
{
    <K_TYPE>
    <OPENING_BRACKET>
    (
        <K_STRICT> { parsingType.setType(JsonTableFunction.JsonTableParsingType.STRICT); }
        |
        LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("LAX") })
                JsonKeyword("LAX") { parsingType.setType(JsonTableFunction.JsonTableParsingType.LAX); }
    )
    <CLOSING_BRACKET>
    {
        return parsingType;
    }
}

JsonTableFunction JsonTableBody() : {
    JsonTableFunction function = new JsonTableFunction();
    Expression jsonInput;
    Expression jsonPath;
    JsonTableFunction.JsonTablePassingClause passingClause;
    String pathName = null;
    JsonTableFunction.JsonTableColumnsClause columnsClause;
    JsonTableFunction.JsonTablePlanClause planClause = null;
    JsonTableFunction.JsonTableOnErrorClause onErrorClause = null;
    JsonTableFunction.JsonTableParsingTypeClause parsingTypeClause = null;
    JsonTableFunction.JsonTableOnEmptyClause onEmptyClause = null;
}
{
    "("
    jsonInput = Expression() {
        function.setJsonInputExpression(jsonInput);
    }
    [ <K_FORMAT> <K_JSON> { function.setFormatJson(true); } ]
    [
        ","
        jsonPath = Expression() {
            function.setJsonPathExpression(jsonPath);
            function.setParameters(new ExpressionList(jsonInput, jsonPath));
        }
        [ <K_AS> pathName = RelObjectName() { function.setPathName(pathName); } ]
    ]
    [
        LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") })
        JsonKeyword("PASSING")
        passingClause = JsonTablePassingClause() { function.addPassingClause(passingClause); }
        (
            ","
            passingClause = JsonTablePassingClause() { function.addPassingClause(passingClause); }
        )*
    ]
    [ LOOKAHEAD(3) onErrorClause = JsonTableOnErrorClause(true) { function.setOnErrorClause(onErrorClause); } ]
    [ parsingTypeClause = JsonTableParsingTypeClause() { function.setParsingTypeClause(parsingTypeClause); } ]
    [ onEmptyClause = JsonTableOnEmptyClause() { function.setOnEmptyClause(onEmptyClause); } ]
    columnsClause = JsonTableColumnsClause() { function.setColumnsClause(columnsClause); }
    [ planClause = JsonTablePlanClause() { function.setPlanClause(planClause); } ]
    [ onErrorClause = JsonTableOnErrorClause(false) { function.setOnErrorClause(onErrorClause); } ]
    ")"
    {
        return function;
    }
}

XmlTableFunction.XmlTablePassingClause XmlTablePassingClause() : {
    XmlTableFunction.XmlTablePassingClause passingClause = new XmlTableFunction.XmlTablePassingClause();
    Expression valueExpression;
    String name = null;
}
{
    valueExpression = Expression() { passingClause.setValueExpression(valueExpression); }
    [ <K_AS> name = RelObjectName() { passingClause.setName(name); } ]
    {
        return passingClause;
    }
}

XmlTableFunction.XmlTableColumnDefinition XmlTableColumnDefinition() : {
    XmlTableFunction.XmlTableColumnDefinition columnDefinition = new XmlTableFunction.XmlTableColumnDefinition();
    String columnName;
    ColDataType dataType;
    Expression expression;
}
{
    columnName = RelObjectName() { columnDefinition.setColumnName(columnName); }
    (
        <K_FOR> <K_ORDINALITY> { columnDefinition.setForOrdinality(true); }
        |
        dataType = ColDataType() { columnDefinition.setDataType(dataType); }
        [ <K_PATH> expression = Expression() { columnDefinition.setPathExpression(expression); } ]
        [ <K_DEFAULT> expression = Expression() { columnDefinition.setDefaultExpression(expression); } ]
    )
    {
        return columnDefinition;
    }
}

XmlTableFunction XmlTableBody() : {
    XmlTableFunction function = new XmlTableFunction();
    Expression rowPath;
    XmlTableFunction.XmlTablePassingClause passingClause;
    XmlTableFunction.XmlTableColumnDefinition columnDefinition;
}
{
    "("
    rowPath = Expression() { function.setRowPathExpression(rowPath); }
    [
        LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") })
        <S_IDENTIFIER>
        passingClause = XmlTablePassingClause() { function.addPassingClause(passingClause); }
        (
            ","
            passingClause = XmlTablePassingClause() { function.addPassingClause(passingClause); }
        )*
    ]
    [
        <K_COLUMNS>
        columnDefinition = XmlTableColumnDefinition() { function.addColumnDefinition(columnDefinition); }
        (
            ","
            columnDefinition = XmlTableColumnDefinition() { function.addColumnDefinition(columnDefinition); }
        )*
    ]
    ")"
    {
        return function;
    }
}

TableFunction TableFunction():
{
    Token prefix = null;
    Function function = null;
    ParenthesedExpressionList<Function> rowsFromFunctions = null;
    Token withClause = null;
}
{
    [ prefix = <K_LATERAL> ]
    (
        LOOKAHEAD(3) <K_ROWS> <K_FROM> rowsFromFunctions = RowsFromFunctionList()
        |
        LOOKAHEAD({
            getToken(1).kind == S_IDENTIFIER
                && getToken(1).image.equalsIgnoreCase("JSON_TABLE")
        })
        JsonKeyword("JSON_TABLE")
        function = JsonTableBody()
        |
        LOOKAHEAD({
            getToken(1).kind == S_IDENTIFIER
                && getToken(1).image.equalsIgnoreCase("XMLTABLE")
        })
        <S_IDENTIFIER>
        function = XmlTableBody()
        |
        function=Function()
    )
    [ LOOKAHEAD(2) <K_WITH> ( withClause = <K_OFFSET> | withClause = <K_ORDINALITY> ) ]
    {
        if (rowsFromFunctions != null) {
            return prefix != null
                ? withClause != null
                    ? new TableFunction(prefix.image, rowsFromFunctions, withClause.image)
                    : new TableFunction(prefix.image, rowsFromFunctions)
                : withClause != null
                    ? new TableFunction(rowsFromFunctions, withClause.image)
                    : new TableFunction(rowsFromFunctions);
        }

        return prefix != null
            ? withClause != null
                ? new TableFunction(prefix.image, function, withClause.image)
                : new TableFunction(prefix.image, function)
            : withClause != null
                ? new TableFunction(function, withClause.image)
                : new TableFunction(function);
    }
}

ParenthesedExpressionList<Function> RowsFromFunctionList():
{
    ParenthesedExpressionList<Function> functions = new ParenthesedExpressionList<Function>();
    Function function;
}
{
    "("
        function = Function() { functions.add(function); }
        (
            ","
            function = Function() { functions.add(function); }
        )*
    ")"
    {
        return functions;
    }
}

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.ColumnParams IndexColumnWithParams(): {
    String columnName = null;
    List<String> parameter = null;
    Expression expression = null;
    Index.ColumnParams column = null;
}
{
    (
        columnName=RelObjectName()
        { parameter = null; }
        [ parameter = CreateParameter() ]
        {
            column = new Index.ColumnParams(columnName, parameter);
        }
        |
        "(" expression=Expression() ")"
        { parameter = null; }
        [ LOOKAHEAD(2) parameter = CreateParameter() ]
        {
            column = new Index.ColumnParams(expression, parameter);
        }
    )
    {
        return column;
    }
}

List<Index.ColumnParams> IndexColumnsWithParamsList() : {
    List<Index.ColumnParams> colNames = new ArrayList<Index.ColumnParams>();
    Index.ColumnParams column = null;
}
{
     "("
    column=IndexColumnWithParams()
    {
        colNames.add(column);
    }

    (
        ","
        column=IndexColumnWithParams()
        {
            colNames.add(column);
        }
    )*

    ")"

    { return colNames; }
}

Index Index(): {
    ObjectNames name;
}
{
    name= RelObjectNames() { return new Index().withName(name.getNames()).withType(""); }
}

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

    <K_INDEX>
    [ LOOKAHEAD(2) <K_IF> <K_NOT> <K_EXISTS> { createIndex.setUsingIfNotExists(true);} ]
    index = Index() { index.setType(parameter.isEmpty() ? null : parameter.get(0)); }
    (
        LOOKAHEAD(3)(
            <K_ON> table=Table()
            [ indexType=UsingIndexType() { index.setUsing(indexType); } ]
        )
        |
        (
            [ indexType=UsingIndexType() {
                    index.setUsing(indexType);
                    createIndex.setIndexTypeBeforeOn(true);
                }
            ]
            <K_ON> table=Table()
        )
    )
    colNames = IndexColumnsWithParamsList()
    [ <K_INCLUDE> includeColumns=ColumnsNamesList()
        { tailParameters.add("INCLUDE (" + String.join(", ", includeColumns) + ")"); }
    ]
    ( LOOKAHEAD(2)  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();
    List<String> schemaPath = null;
    List<Statement> statements = new ArrayList<Statement>();
}
{
    <K_SCHEMA>
    [ LOOKAHEAD(2) <K_IF> <K_NOT> <K_EXISTS> { schema.setIfNotExists(true); } ]
    [
        ( tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) { schema.setSchemaName(tk.image); }

        (
            "." { schema.setCatalogName(tk.image); }
            ( 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(2) (
            <K_CREATE>

            table = CreateTable(false)
            {
                table.getTable().setSchemaName(schema.getSchemaName());
                schema.addStatement(table);
            }
            |
            view = CreateView(false)
            {
                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;
    }
}

CreateDatabase CreateDatabase():
{
    CreateDatabase createDatabase = new CreateDatabase();
    String databaseName = null;
    List<String> databaseOptions = null;
}
{
    <K_DATABASE>
    [ LOOKAHEAD(2) <K_IF> <K_NOT> <K_EXISTS> { createDatabase.setIfNotExists(true); } ]
    databaseName = RelObjectName() { createDatabase.setDatabaseName(databaseName); }
    [ databaseOptions = captureRest() { createDatabase.setDatabaseOptions(databaseOptions); } ]
    {
        return createDatabase;
    }
}

/**
 * Parses a single table-level constraint inside CREATE TABLE (...).
 * Handles INDEX, PRIMARY KEY, UNIQUE, KEY, FOREIGN KEY, CHECK, EXCLUDE.
 * Returns an Index (which may be NamedConstraint, ForeignKeyIndex, CheckConstraint, ExcludeConstraint).
 */
Index CreateTableConstraint():
{
    Token tk = null;
    Token tk2 = null;
    Token tk3 = null;
    String sk3 = null;
    List<Index.ColumnParams> colNames = null;
    List<String> parameter = new ArrayList<String>();
    List<String> idxSpec = new ArrayList<String>();
    Index index = null;
    ForeignKeyIndex fkIndex = null;
    CheckConstraint checkCs = null;
    ExcludeConstraint excludeC = null;
    Expression exp = null;
}
{
    (
        LOOKAHEAD(4) (
            { idxSpec.clear(); tk3=null; }
            [ tk3=<K_UNIQUE> ]
            tk=<K_INDEX>
            sk3=RelObjectName()
            colNames = IndexColumnsWithParamsList()
            ( parameter=CreateParameter() { idxSpec.addAll(parameter); } )*
            {
                index = new Index().withType((tk3!=null ? tk3.image + " " : "") + tk.image).withName(sk3).withColumns(colNames).withIndexSpec(new ArrayList<String>(idxSpec));
            }
        )
        |
        LOOKAHEAD(3) (
            {
                index = new NamedConstraint();
                tk2=null;
                idxSpec.clear();
            }
            [ <K_CONSTRAINT> sk3=RelObjectName() {index.setName(sk3);} ]
            (
                tk=<K_PRIMARY> tk2=<K_KEY>
                |
                tk=<K_UNIQUE> [ tk2=<K_KEY> ]
            )
            {
                index.setType( tk.image + ( tk2!=null ? " " + tk2.image : "" ));
                tk2=null;
            }
            colNames = ColumnNamesWithParamsList()
            ( parameter=CreateParameter() { idxSpec.addAll(parameter); } )*
            {
                index.withColumns(colNames).withIndexSpec(new ArrayList<String>(idxSpec));
            }
        )
        |
        LOOKAHEAD(3) (
            {
                tk=null;
                tk3=null;
                idxSpec.clear();
            }
            [ tk=<K_UNIQUE> ]
            [ tk3=<K_FULLTEXT> | tk3=<K_SPATIAL> ] tk2=<K_KEY>
            sk3=RelObjectName()
            colNames = IndexColumnsWithParamsList()
            ( 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));
            }
        )
        |
        LOOKAHEAD(3) (
            { sk3=null; }
            [ <K_CONSTRAINT> sk3=RelObjectName() ]
            fkIndex = ForeignKeySpec(sk3)
            { index = fkIndex; }
        )
        |
        LOOKAHEAD(3) (
            { sk3 = null; }
            [ <K_CONSTRAINT> sk3 = RelObjectName() ]
            checkCs = CheckConstraintSpec(sk3)
            { index = checkCs; }
        )
        |
        LOOKAHEAD(2) (
            tk=<K_EXCLUDE> { excludeC = new ExcludeConstraint(); }
            (tk2=<K_WHERE>
                ("(" exp = Expression() ")")* {excludeC.setExpression(exp);})
            { index = excludeC; }
        )
    )
    {
        return index;
    }
}


CreateTable CreateTable(boolean isUsingOrReplace):
{
    CreateTable createTable = new CreateTable();
    Table table = null;
    List<ColumnDefinition> columnDefinitions = new ArrayList<ColumnDefinition>();
    List<String> tableOptions = new ArrayList<String>();
    List<String> createOptions = new ArrayList<String>();
    Token tk = null;
    ColumnDefinition coldef = null;
    List<Index> indexes = new ArrayList<Index>();
    Index index = null;
    List<String> parameter = new ArrayList<String>();
    SpannerInterleaveIn interleaveIn = null;
    Select select = null;
    Table likeTable = null;
    RowMovement rowMovement = null;
    String tableColumn = null;
    List<String> columns = new ArrayList<String>();
}
{
    { createTable.setOrReplace(isUsingOrReplace);}
    [ <K_UNLOGGED> { createTable.setUnlogged(true); } ]

    // table options, not required but 1 or none
    [ tk=<K_GLOBAL> { 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) (
                            index = CreateTableConstraint()
                            { indexes.add(index); }
                        )
                        |
                        (
                            coldef = ColumnDefinition()
                            { 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 = Select() { createTable.setSelect(select, false); }]
    [
    <K_LIKE> ( LOOKAHEAD("(" Table() ")") "(" likeTable=Table() { createTable.setLikeTable(likeTable, true); } ")"
                 | likeTable=Table() { createTable.setLikeTable(likeTable, false); } )
    ]
    [ <K_COMMA> interleaveIn = SpannerInterleaveIn( ) { createTable.setSpannerInterleaveIn(interleaveIn); } ]
    {
        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;
    }
}

SpannerInterleaveIn SpannerInterleaveIn():
{
    Table table = null;
    SpannerInterleaveIn.OnDelete action = null;
}
{
    <K_INTERLEAVE> <K_IN> <K_PARENT> table = Table()
    [
        <K_ON> <K_DELETE>
            (
                    <K_NO> <K_ACTION> { action = SpannerInterleaveIn.OnDelete.NO_ACTION; }
                    | <K_CASCADE> { action = SpannerInterleaveIn.OnDelete.CASCADE; }
            )
    ]
    {
        return new SpannerInterleaveIn(table, action);
    }
}


ColDataType DataType():
{
    ColDataType colDataType = new ColDataType();
    Token prefix = null;
    Token tk = null;
    Token tk2 = null;
    String schema;
    String type="";
    List<String> argumentsStringList = new ArrayList<String>();
    List<Integer> array = new ArrayList<Integer>();
    List<String> name;
    ColDataType arrayType;

    int precision = -1;
    int scale = -1;
}
{
    (
        LOOKAHEAD(2) tk=<K_TEXT_LITERAL> {
            type = tk.image;
            return new ColDataType(type, precision, scale);
        }
        |
		LOOKAHEAD(2) tk=<K_ARRAY_LITERAL> (
            ("<" arrayType = ColDataType() ">") {
                 colDataType.setDataType("ARRAY<" + arrayType.getDataType() + ">");
            }
        )
        |
        (
            ( tk=<K_DATETIMELITERAL> | tk=<DT_ZONE> | tk = <DATA_TYPE>  | tk = <K_SIGNED>  | tk = <K_UNSIGNED>
                | tk=<K_CHARACTER>  |  tk=<K_BIT> | tk=<K_BYTES> | tk=<K_BINARY> | tk=<K_BOOLEAN>
                | tk=<K_CHAR> | tk=<K_JSON> | tk=<K_STRING> ) { type = tk.image; }
            [
                // MySQL seems to allow: INT UNSIGNED
                LOOKAHEAD(2) ( LOOKAHEAD(2) ( tk = <DATA_TYPE>  | tk = <K_SIGNED>  | tk = <K_UNSIGNED>
                                   | tk=<K_CHARACTER>  | tk=<K_BIT> | tk=<K_BYTES> | tk=<K_BINARY> | tk=<K_BOOLEAN>
                                   | tk=<K_CHAR> | tk=<K_JSON>  | tk=<K_STRING> ) { type += " " + tk.image; } )+
            ]
            [
                LOOKAHEAD(2) "(" ( tk=<S_LONG> { precision = Integer.valueOf(tk.image); } |  tk=<K_MAX> { precision = Integer.MAX_VALUE; } )
                [ <K_BYTE> | <K_CHAR> ]
                [ "," tk = <S_LONG> { scale = Integer.valueOf(tk.image); } ]
                ")"
            ]
            {
                colDataType = new ColDataType(type, precision, scale);
            }
        )
    )

    {
        return colDataType;
    }
}

ColDataType ColDataType():
{
    ColDataType colDataType = new ColDataType();
    Token prefix = null;
    Token tk = null;
    Token tk2 = null;
    String schema;
    String type="";
    List<String> argumentsStringList = new ArrayList<String>();
    List<Integer> array = new ArrayList<Integer>();
    List<String> name;
    ColDataType arrayType;
    ColDataType nestedType = null;
    IntervalQualifier intervalQualifier = null;

    int precision = -1;
    int scale = -1;
}
{
    (
        (
            <K_STRUCT>
            "("
            type = RelObjectNameExt()
            colDataType = ColDataType() { argumentsStringList.add( type + " " + colDataType.toString()); }
            (
                ","
                type = RelObjectNameExt()
                colDataType = ColDataType() { argumentsStringList.add( type + " " + colDataType.toString()); }
            )*
            ")" { colDataType = new ColDataType("STRUCT"); }
        )
		|
		LOOKAHEAD(2) (
            colDataType = DataType()
        )
        |
		(
		    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>
			| tk=<K_STRING>
			| tk=<K_PUBLIC>
			| tk=<K_DATA>
			| tk=<K_NAME>
        ) { schema = tk.image; }

        // Consume an optional INTERVAL qualifier such as `hour to minute` or
        // `day(9) to second`. Only applicable when the matched type is an INTERVAL and
        // is immediately followed by a field word, so other types (and the existing
        // `interval (2)` precision form handled below) are unaffected.
        [
            LOOKAHEAD({ "interval".equalsIgnoreCase(schema)
                    && getToken(1).kind == K_DATE_LITERAL })
            intervalQualifier = IntervalQualifier() { colDataType.setIntervalQualifier(intervalQualifier); }
        ]
        [ LOOKAHEAD(2) "."  arrayType = ColDataType()  { schema += "." + arrayType.toString(); } ]
        { colDataType.setDataType(schema); }
    )

    [
        LOOKAHEAD(2) "(" {tk2 =null;}
        (
            (
            LOOKAHEAD((<DATA_TYPE> | <S_IDENTIFIER>) "(") nestedType=ColDataType()
            |
            (
                (
                    ( tk=<S_LONG> | tk=<K_MAX> ) [ LOOKAHEAD(2) (tk2=<K_BYTE> | tk2=<K_CHAR>) ]
                )
                |
                tk=<S_CHAR_LITERAL>
                |
                tk=<S_IDENTIFIER>
                |
                tk=<K_CHAR>
            )
            )
		    {
            if (nestedType != null) {
                argumentsStringList.add(nestedType.toString());
                nestedType = null;
            } else {
                argumentsStringList.add(tk.image + (tk2!=null?" " + tk2.image:""));
            }
            }

            [ "," ]
        )*
        ")"
    ]
    [ LOOKAHEAD(2) ( LOOKAHEAD(2) "[" {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;
    }
}

ExpressionList<Column> ColumnWithCommentList():
{
    ExpressionList<Column> expressions = new ExpressionList<Column>();
    Column img = null;
}
{
    "("
         img=Column() { expressions.add(img); }
         ( "," img=Column() { expressions.add(img); } )*
    ")"
    {
        return expressions;
    }
}


CreateView CreateView(boolean isUsingOrReplace):
{
    CreateView createView = new CreateView();
    Table view = null;
    Select select = null;
    ExpressionList<Column> columnNames = null;
    Token tk = null;
    List<String> commentTokens = null;
}
{
    { createView.setOrReplace(isUsingOrReplace);}
    [
        <K_NO> <K_FORCE> { createView.setForce(ForceOption.NO_FORCE); }
        | <K_FORCE> { createView.setForce(ForceOption.FORCE); }
    ]
    [ <K_SECURE> { createView.setSecure(true);} ]
    [
        <K_TEMP> { createView.setTemporary(TemporaryOption.TEMP); }
        | <K_TEMPORARY> { createView.setTemporary(TemporaryOption.TEMPORARY); }
        | <K_VOLATILE> { createView.setTemporary(TemporaryOption.VOLATILE); }
    ]
    [ <K_MATERIALIZED> { createView.setMaterialized(true);} ]
    <K_VIEW> view=Table() { createView.setView(view); }
    [LOOKAHEAD(3) <K_AUTO> <K_REFRESH> (tk=<K_YES> | tk=<K_NO>) { createView.setAutoRefresh(AutoRefreshOption.from(tk.image)); } ]
    [LOOKAHEAD(3) <K_IF> <K_NOT> <K_EXISTS> {createView.setIfNotExists(true);}]
    [ columnNames=ColumnWithCommentList( ) { createView.setColumnNames(columnNames); } ]
    [ commentTokens=CreateViewTailComment( ) { createView.setViewCommentOptions(commentTokens); } ]
    <K_AS>
    select=Select( ) { createView.setSelect(select); }
    [ LOOKAHEAD(2)  <K_WITH> <K_READ> <K_ONLY> { createView.setWithReadOnly(true); } ]
    { return createView; }
}

List<String> CreateViewTailComment():
{
    Token tk = null;
    Token tk2 = null;
    String op = null;
    List<String> result = new ArrayList<String>();
}
{
    tk=<K_COMMENT>
    [ "=" { op = "="; } ]
    tk2 = <S_CHAR_LITERAL> {
         result.add("");
         result.add(tk.image);
         if (op != null) {
             result.add(op);
         }
         result.add(tk2.image);
    }
    { return result;}
}


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; }
}

/**
 * Parses optional referential actions: [ON DELETE|UPDATE action] [ON DELETE|UPDATE action]
 * Shared between CREATE TABLE FK and ALTER TABLE FK definitions.
 */
void ReferentialActionsOnIndex(ForeignKeyIndex fkIndex):
{
    Token tk;
    ReferentialAction.Action action = null;
}
{
    [ LOOKAHEAD(2) (
        <K_ON>
        ( tk=<K_DELETE> | tk=<K_UPDATE> ) action = Action()
        { fkIndex.setReferentialAction(ReferentialAction.Type.from(tk.image), action); }
    )]
    [ LOOKAHEAD(2) (
        <K_ON>
        ( tk=<K_DELETE> | tk=<K_UPDATE> ) action = Action()
        { fkIndex.setReferentialAction(ReferentialAction.Type.from(tk.image), action); }
    )]
}

/**
 * Parses: CHECK ( expression )
 * Returns a CheckConstraint. Shared between CREATE TABLE and ALTER TABLE.
 */
CheckConstraint CheckConstraintSpec(String constraintName):
{
    Expression exp = null;
}
{
    <K_CHECK> ( LOOKAHEAD(2) "(" exp = Expression() ")" )*
    {
        return new CheckConstraint().withName(constraintName).withExpression(exp);
    }
}

/**
 * Parses: FOREIGN KEY columns REFERENCES table [columns] [referential actions]
 * Returns a populated ForeignKeyIndex. Shared between CREATE TABLE and ALTER TABLE.
 */
ForeignKeyIndex ForeignKeySpec(String constraintName):
{
    ForeignKeyIndex fkIndex = new ForeignKeyIndex();
    Token tk;
    Token tk2;
    List<String> refColNames = null;
    List<Index.ColumnParams> colNames;
    Table fkTable;
}
{
    tk=<K_FOREIGN> tk2=<K_KEY>
    colNames = ColumnNamesWithParamsList()
    {
        if (constraintName != null) { fkIndex.setName(constraintName); }
        fkIndex.withType(tk.image + " " + tk2.image).withColumns(colNames);
    }
    <K_REFERENCES> fkTable=Table() [ LOOKAHEAD(2) refColNames=ColumnsNamesList() ]
    {
        fkIndex.setTable(fkTable);
        fkIndex.setReferencedColumnNames(refColNames);
    }
    ReferentialActionsOnIndex(fkIndex)
    {
        return fkIndex;
    }
}

/**
 * Parses USING [INDEX] name clause in ALTER TABLE constraint tails.
 */
void AlterExpressionUsingIndex(AlterExpression alterExp):
{
    String sk4;
}
{
    <K_USING> { alterExp.addParameters("USING"); }
    [ LOOKAHEAD(2) <K_INDEX> { alterExp.addParameters("INDEX"); } ]
    sk4=RelObjectName() { alterExp.addParameters(sk4); }
}

/**
 * Parses the common tail after a named constraint in ALTER TABLE:
 * constraint_state [USING [INDEX] name] [COMMENT 'text']
 */
void AlterExpressionConstraintTail(AlterExpression alterExp, Index index):
{
    List<ConstraintState> constraints;
}
{
    constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
    [ LOOKAHEAD(2) AlterExpressionUsingIndex(alterExp) ]
    [ LOOKAHEAD(2) index = IndexWithComment(index) { alterExp.setIndex(index); } ]
}

AlterView AlterView(boolean useReplace):
{
    AlterView alterView = new AlterView();
    Table view = null;
    Select select = null;
    List<String> columnNames = null;
}
{
    <K_VIEW> view=Table() { alterView.setView(view); alterView.setUseReplace(useReplace); }
    [ columnNames = ColumnsNamesList() { alterView.setColumnNames(columnNames); } ]
    <K_AS>
    select=Select()
    {
        alterView.setSelect(select);
        return alterView;
    }
}

List<String> CreateParameter():
{
    String retval = "";
    Token tk = null, tk2 = null;
    Expression exp = null;
    ColDataType colDataType;
    List<String> param = new ArrayList<String>();
}
{
    (
        // Postgres: nextval('public.actor_actor_id_seq'::regclass)
        ( <K_NEXTVAL> "("  tk=<S_CHAR_LITERAL> "::" colDataType = ColDataType() ")" )
        {
            param.add("NextVal( " + tk.image + "::" + colDataType + ")" );
        }
        |
        (
            //@todo: implement a proper identifier
            (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER> | tk=<K_NAME>)
            { retval+=tk.image; }

            [
                "."
                //@todo: implement a proper identifier
                (tk2=<S_IDENTIFIER> | tk2=<S_QUOTED_IDENTIFIER> | tk=<K_NAME>)
                { retval+="."+tk2.image; }
            ]
            { param.add(retval); }
        )
        |
        LOOKAHEAD(3) [<K_USING> <K_INDEX> { param.add("USING INDEX"); }] <K_TABLESPACE> retval=RelObjectName()
        { param.add("TABLESPACE " + retval); }
        |
        (
            tk=<S_CHAR_LITERAL> | tk=<K_NULL> | tk=<K_NOT> | tk=<K_AUTO_INCREMENT> | tk=<K_PRIMARY> | tk=<K_FOREIGN>
            | tk=<K_REFERENCES> | tk=<K_KEY> | tk=<K_STORED> | tk=<K_ON> | tk=<K_COMMIT> | tk=<K_DROP>
            | tk=<K_ROWS> | tk=<K_UNIQUE> | tk=<K_CASCADE> | tk=<K_DELETE> | tk=<K_UPDATE>
            | tk=<K_CONSTRAINT> | tk=<K_WITH> | tk=<K_EXCLUDE> | tk=<K_WHERE>
            | tk=<K_TEMP> | tk=<K_TEMPORARY> | tk=<K_PARTITION> | tk=<K_BY> | tk=<K_IN>
            | tk=<K_TYPE> | tk=<K_COMMENT> | tk=<K_USING> | tk=<K_COLLATE> | tk=<K_ASC>
            | tk=<K_DESC> | tk=<K_TRUE> | tk=<K_FALSE> | tk=<K_PARALLEL> | tk=<K_BINARY> | tk=<K_START> | tk=<K_ORDER>
            | tk=<K_TIME_KEY_EXPR> | tk=<K_RAW> | tk=<K_HASH> | tk=<K_FIRST> | tk=<K_LAST> | tk = <K_SIGNED>  | tk = <K_UNSIGNED>
            | tk=<K_ENGINE> | tk=<K_IDENTITY> | tk=<K_MATERIALIZED> | tk=<K_SAMPLE> | tk=<K_ALWAYS>
            | tk=<K_VISIBLE> | tk=<K_INVISIBLE>
            | tk="="
        )
        { param.add(tk.image); }
        |
        ( tk=<K_DEFAULT> | tk=<K_AS> | tk=<K_CHECK> ) [ LOOKAHEAD(2) "(" exp = Expression() ")" ]
        {
            param.add(tk.image);
            if (exp!=null) {
                param.add("(" + exp + ")");
            }
        }
        |
        (
            [ ( tk="+" | tk="-" ) { retval = tk.image; } ]
            tk=<S_LONG> | tk=<S_DOUBLE>
        )
        { param.add( retval + tk.image ); }
        |
        retval=AList() { param.add(retval); }
        |
        (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> | tk=<K_TRUE> | tk=<K_FALSE>) { retval.append(tk.image); }
         | (name=RelObjectName()) { retval.append(name); })
       [("," {retval.append(",");} | "=" {retval.append("=");})] )*

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

String ColumnsNamesListItem():
{
	Token tk = null;
    Token sortDirection = null;
    String item = null;
}
{
	( item = RelObjectName() )
	[ LOOKAHEAD(2)  "(" tk = <S_LONG>  ")" { item = item + "(" + tk.image + ")"; } ]
    [ LOOKAHEAD( ( <K_ASC> | <K_DESC> ) ( "," | ")" ) ) (sortDirection = <K_ASC> | sortDirection = <K_DESC>) { item = item + " " + sortDirection.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;
    boolean useTemporary = false;
}
{
    <K_DROP>
    [ <K_MATERIALIZED> { drop.setMaterialized(true);} ]
    (
        tk=<S_IDENTIFIER>
        |
        (
            [ <K_TEMPORARY> {useTemporary=true;} ] 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); }
    [ LOOKAHEAD(2)  funcArgs = FuncArgsList() ]
    (
        (
            tk=<S_IDENTIFIER> | tk=<K_CASCADE> | tk=<K_RESTRICT>
        ) { dropArgs.add(tk.image); }
        |
        (
            <K_ON> name = Table() { dropArgs.add("ON"); dropArgs.add(name.toString()); }
        )
    )*
    {
        if (dropArgs.size() > 0) {
            drop.setParameters(dropArgs);
        }
        if (drop.getType().equals("FUNCTION")) {
            drop.getTypeToParameters().put("FUNCTION", funcArgs);
        }

        drop.setUsingTemporary(useTemporary);

        return drop;
    }
}

Truncate Truncate():
{
    Truncate truncate = new Truncate();
    Table table;
    List<Table> tables = new ArrayList<Table>();
    boolean only = false;
    boolean cascade = false;
}
{
/**
* 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>  { only = true; }]
    table=Table() { tables.add(table); } (LOOKAHEAD(2) "," table=Table() { tables.add(table); } )*
    [<K_CASCADE> { cascade = true; }]
    {
       if (only && tables.size() > 1 ) {
          throw new ParseException("Cannot TRUNCATE ONLY with multiple tables");
       } else {
          return truncate
             .withTables(tables)
             .withTable(table)
             .withOnly(only)
             .withCascade(cascade);
       }
    }
}

/**
 * Parses common column-level changes shared between the COLUMN-prefixed and bare forms:
 * DROP DEFAULT, SET DEFAULT, SET VISIBLE/INVISIBLE, and bracketed multi-column definitions.
 */
void AlterExpressionColumnChanges(AlterExpression alterExp):
{
    AlterExpression.ColumnDataType alterExpressionColumnDataType = null;
    AlterExpression.ColumnDropDefault alterExpressionColumnDropDefault = null;
    AlterExpression.ColumnSetDefault alterExpressionColumnSetDefault = null;
    AlterExpression.ColumnSetVisibility alterExpressionColumnSetVisibility = null;
}
{
    (
        LOOKAHEAD(3) alterExpressionColumnDropDefault = AlterExpressionColumnDropDefault()
            { alterExp.addColDropDefault(alterExpressionColumnDropDefault); }
        |
        LOOKAHEAD(3) alterExpressionColumnSetDefault = AlterExpressionColumnSetDefault()
            { alterExp.addColSetDefault(alterExpressionColumnSetDefault); }
        |
        LOOKAHEAD(3) alterExpressionColumnSetVisibility = AlterExpressionColumnSetVisibility()
            { alterExp.addColSetVisibility(alterExpressionColumnSetVisibility); }
        |
        LOOKAHEAD(4) (
            "("
                { alterExp.useBrackets(true);}
                alterExpressionColumnDataType = AlterExpressionColumnDataType() {
                    alterExp.addColDataType(alterExpressionColumnDataType);
                }
                (
                    ","
                    alterExpressionColumnDataType = AlterExpressionColumnDataType() {
                        alterExp.addColDataType(alterExpressionColumnDataType);
                    }
                )*
            ")"
        )
    )
}


AlterExpression.ColumnDataType AlterExpressionColumnDataType():
{
    String columnName = null;
    boolean withType = false;
    ColDataType dataType = null;
    List<String> columnSpecs = null;
    List<String> parameter = null;
}
{
    columnName = RelObjectName() { columnSpecs = new ArrayList<String>(); }
    ( LOOKAHEAD(2) <K_TYPE> { withType = true; } )?
    ( LOOKAHEAD(2) dataType = ColDataType() )?
    ( LOOKAHEAD(2) 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);
    }
}

AlterExpression.ColumnSetDefault AlterExpressionColumnSetDefault():
{
    String columnName = null;
    Expression defaultValue = null;
}
{
    columnName = RelObjectName() <K_SET> <K_DEFAULT> defaultValue = Expression()
    {
        return new AlterExpression.ColumnSetDefault(columnName, defaultValue.toString());
    }
}

AlterExpression.ColumnSetVisibility AlterExpressionColumnSetVisibility():
{
    String columnName = null;
    boolean visible = true;
}
{
    columnName = RelObjectName() <K_SET>
    (
        <K_VISIBLE> { visible = true; } |
        <K_INVISIBLE> { visible = false; }
    )
    {
        return new AlterExpression.ColumnSetVisibility(columnName, visible);
    }
}

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;
    }
}

Index IndexWithComment(Index index):
{
    Token tk = null;
}
{
    <K_COMMENT> tk=<S_CHAR_LITERAL> {
        index.setCommentText(tk.image);
    }
    {
        return index;
    }
}

void IndexOptionList(List<String> list) :
{}
{
    (
       LOOKAHEAD(2) IndexOption(list)
    )*
}

String UsingIndexType() :
{
    String sk = null;
}
{
    <K_USING> ( sk = RelObjectName() )
    {
        return sk;
    }
}

void IndexOption(List<String> list) :
{
    Token tk1 = null;
    Token tk2 = null;
    String sk1 = null;
    boolean useEqual = false;
}
{
    (
      tk1=<K_KEY_BLOCK_SIZE> ["=" { useEqual = true; } ] tk2=<S_LONG>
      {
        list.add("KEY_BLOCK_SIZE" +  (useEqual ? " = " : "") + tk2.image);
      }
    |
      tk1=<K_WITH> <K_PARSER> tk2=<S_IDENTIFIER>
      {
        list.add("WITH PARSER " + tk2.image);
      }
    |
      tk1=<K_COMMENT> tk2=<S_CHAR_LITERAL>
      {
        list.add("COMMENT " + tk2.image);
      }
    |
      tk1=<K_VISIBLE>
      {
        list.add("VISIBLE");
      }
    |
      tk1=<K_INVISIBLE>
      {
        list.add("INVISIBLE");
      }
    |
      sk1 = UsingIndexType(){
        list.add("USING " + sk1);
      }
    )
}

List<PartitionDefinition> PartitionDefinitions():
{
    Token tk;
    List<PartitionDefinition> partitionDefinitions = new ArrayList<PartitionDefinition>();
    PartitionDefinition partitionDef = null;
    String partitionName = null;
    String partitionOperation = null;
    String storageEngine = null;
    Expression exp = null;
}
{
    "("
        (
            <K_PARTITION>
            partitionName=RelObjectName()
            {
                List<String> values = new ArrayList<String>();
            }
            <K_VALUES>
            (
                <K_LESS> <K_THAN>
                (
                    "(" exp = Expression() ")"{
                        values.add(exp.toString());
                    }
                    | <K_MAXVALUE> { values.add("MAXVALUE"); }
                ) {
                    partitionOperation = "VALUES LESS THAN";
                }
            )
            [ "ENGINE" "=" tk=<S_IDENTIFIER> { storageEngine = tk.image; } ]
            {
                partitionDef = new PartitionDefinition(partitionName, partitionOperation, values, storageEngine);
                partitionDefinitions.add(partitionDef);
            }
            [ "," ]
        )*
    ")"
    {
        return partitionDefinitions;
    }
}

List<String> PartitionNamesList() :
{
    Token tk;
    List<String> partitionNames = new ArrayList<String>();
}
{
    (
        tk = <K_ALL> {
            partitionNames.add(tk.image);
        }
        |
        tk = <S_IDENTIFIER> {
            partitionNames.add(tk.image);
        }
        (
            LOOKAHEAD(2) "," tk = <S_IDENTIFIER> {
                partitionNames.add(tk.image);
            }
        )*
    )
    {
        return partitionNames;
    }
}

/**
 * Parses DISCARD/IMPORT (PARTITION names TABLESPACE | TABLESPACE).
 * Both keywords share the same structure, differing only in operation enum.
 */
AlterExpression AlterExpressionDiscardOrImport():
{
    AlterExpression alterExp;
    List<String> partitions = null;
    AlterOperation partOp;
    AlterOperation tableOp;
}
{
    (
        <K_DISCARD> { partOp = AlterOperation.DISCARD_PARTITION; tableOp = AlterOperation.DISCARD_TABLESPACE; }
        |
        <K_IMPORT> { partOp = AlterOperation.IMPORT_PARTITION; tableOp = AlterOperation.IMPORT_TABLESPACE; }
    )
    (
        <K_PARTITION>
        { alterExp = new AlterExpressionPartition(); alterExp.setOperation(partOp); }
        partitions = PartitionNamesList()
        { alterExp.setPartitions(partitions); }
        <K_TABLESPACE>
        { alterExp.setTableOption("TABLESPACE"); }
        |
        <K_TABLESPACE>
        { alterExp = new AlterExpressionTableOption(); alterExp.setOperation(tableOp); }
    )
    { return alterExp; }
}


/**
 * Parses ADD/ALTER CONSTRAINT clause within AlterExpression.
 * Handles: CONSTRAINT [UNIQUE [KEY|INDEX]] name columns
 *          CONSTRAINT name (FOREIGN KEY|PRIMARY KEY|UNIQUE|KEY|CHECK|[NOT] ENFORCED)
 */
void AlterExpressionAddConstraint(AlterExpression alterExp):
{
    Token tk;
    Token tk2 = null;
    String sk3 = null;
    List<String> columnNames = null;
    ForeignKeyIndex fkIndex = null;
    Index index = null;
    Table fkTable;
    List<ConstraintState> constraints = null;
    CheckConstraint checkCs = null;
}
{
    <K_CONSTRAINT>
    (
        LOOKAHEAD(2)
        (
            <K_UNIQUE> (<K_KEY> { alterExp.setConstraintType("UNIQUE KEY"); }
            | <K_INDEX> { alterExp.setConstraintType("UNIQUE INDEX"); }
            | { alterExp.setConstraintType("UNIQUE"); } )
            sk3=RelObjectName() {
              alterExp.setConstraintSymbol(sk3);
              index = new Index();
            }
            columnNames=ColumnsNamesList() {
              index.setColumnsNames(columnNames);
              alterExp.setIndex(index);
            }
        )
        |
        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() [ LOOKAHEAD(2) columnNames=ColumnsNamesList() ]
                {
                    fkIndex.withTable(fkTable).withReferencedColumnNames(columnNames);
                    alterExp.setIndex(fkIndex);
                }
                ReferentialActionsOnIndex(fkIndex)
                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);
                }
                AlterExpressionConstraintTail(alterExp, index)
            )
            |
            LOOKAHEAD(2) (
                { boolean enforced = true; }
                [ tk = <K_NOT> { enforced = false; } ]
                <K_ENFORCED> {
                    alterExp.setEnforced(enforced);
                    alterExp.setConstraintType("CONSTRAINT");
                    alterExp.setConstraintSymbol(sk3);
                }
            )
            |
            (
                checkCs = CheckConstraintSpec(sk3)
                { 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);
                  }
                  AlterExpressionConstraintTail(alterExp, index)
            )
            |
            (
                tk=<K_KEY>
                columnNames=ColumnsNamesList()
                {
                    index = new NamedConstraint()
                      .withName(sk3)
                      .withType(tk.image)
                      .withColumnsNames(columnNames);
                    alterExp.setIndex(index);
                }
                constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
            )
        )
    )
}

/**
 * Parses the DROP operations within AlterExpression.
 * Handles: DROP (PARTITION|columns|COLUMN|INDEX|KEY|UNIQUE|PRIMARY KEY|FOREIGN KEY|CONSTRAINT)
 */
AlterExpression AlterExpressionDrop():
{
    AlterExpression alterExp = new AlterExpressionDrop();
    Token tk;
    Token tk2;
    List<String> columnNames = null;
    List<String> partitions = null;
    Index index = null;
}
{
    <K_DROP> { alterExp.setOperation(AlterOperation.DROP); }
    (
        (
            <K_PARTITION> {
                alterExp.setOperation(AlterOperation.DROP_PARTITION);
            }
            partitions=PartitionNamesList() {
                alterExp.setPartitions(partitions);
            }
        )
        |
        (
            // Oracle Multi Column Drop
            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=KeywordOrIdentifier() ) { alterExp.setColumnName(tk.image); }
            [ "INVALIDATE" { alterExp.addParameters("INVALIDATE"); } ]
            [
                "CASCADE" { alterExp.addParameters("CASCADE"); }
                [ "CONSTRAINTS" { alterExp.addParameters("CONSTRAINTS"); } ]
            ]
        )
        |
        (
           ( tk=<K_INDEX> | tk=<K_KEY> )
           ( 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); } ]
        )
    )
    { return alterExp; }
}

/**
 * Parses partition maintenance operations within AlterExpression.
 * Handles: TRUNCATE/ANALYZE/CHECK/OPTIMIZE/REBUILD/REPAIR PARTITION,
 *          COALESCE/REORGANIZE/EXCHANGE/PARTITION BY, REMOVE PARTITIONING
 */
AlterExpression AlterExpressionPartitionOp():
{
    AlterExpression alterExp = new AlterExpressionPartition();
    Token tk;
    List<String> partitions = null;
    List<PartitionDefinition> partitionDefinition = null;
    List<String> columnNames = null;
    Expression exp = null;
}
{
    (
        LOOKAHEAD(2) <K_TRUNCATE> <K_PARTITION> { alterExp.setOperation(AlterOperation.TRUNCATE_PARTITION); }
        partitions=PartitionNamesList() { alterExp.setPartitions(partitions); }
    |
        LOOKAHEAD(2) <K_COALESCE> <K_PARTITION> tk=<S_LONG> {
            alterExp.setOperation(AlterOperation.COALESCE_PARTITION);
            alterExp.setCoalescePartitionNumber(Integer.valueOf(tk.image));
        }
    |
        LOOKAHEAD(2) <K_REORGANIZE> <K_PARTITION>
        partitions=PartitionNamesList() <K_INTO> partitionDefinition=PartitionDefinitions() {
            alterExp.setOperation(AlterOperation.REORGANIZE_PARTITION);
            alterExp.setPartitions(partitions);
            alterExp.setPartitionDefinitions(partitionDefinition);
        }
    |
        LOOKAHEAD(2) <K_EXCHANGE> <K_PARTITION> partitions=PartitionNamesList()
        <K_WITH> <K_TABLE> tk=<S_IDENTIFIER>
        [
            LOOKAHEAD(2) (
                <K_WITH> <K_VALIDATION> { alterExp.setExchangePartitionWithValidation(true); }
                |
                <K_WITHOUT> <K_VALIDATION> { alterExp.setExchangePartitionWithoutValidation(false); }
            )
        ]
        {
            alterExp.setOperation(AlterOperation.EXCHANGE_PARTITION);
            alterExp.setPartitions(partitions);
            alterExp.setExchangePartitionTableName(tk.image);
        }
    |
        LOOKAHEAD(2) <K_ANALYZE> <K_PARTITION> { alterExp.setOperation(AlterOperation.ANALYZE_PARTITION); }
        partitions=PartitionNamesList() { alterExp.setPartitions(partitions); }
    |
        LOOKAHEAD(2) <K_CHECK> <K_PARTITION> { alterExp.setOperation(AlterOperation.CHECK_PARTITION); }
        partitions=PartitionNamesList() { alterExp.setPartitions(partitions); }
    |
        LOOKAHEAD(2) <K_OPTIMIZE> <K_PARTITION> { alterExp.setOperation(AlterOperation.OPTIMIZE_PARTITION); }
        partitions=PartitionNamesList() { alterExp.setPartitions(partitions); }
    |
        LOOKAHEAD(2) <K_REBUILD> <K_PARTITION> { alterExp.setOperation(AlterOperation.REBUILD_PARTITION); }
        partitions=PartitionNamesList() { alterExp.setPartitions(partitions); }
    |
        LOOKAHEAD(2) <K_REPAIR> <K_PARTITION> { alterExp.setOperation(AlterOperation.REPAIR_PARTITION); }
        partitions=PartitionNamesList() { alterExp.setPartitions(partitions); }
    |
        LOOKAHEAD(2) <K_REMOVE> <K_PARTITIONING> { alterExp.setOperation(AlterOperation.REMOVE_PARTITIONING); }
    |
        LOOKAHEAD(2) <K_PARTITION> <K_BY> { alterExp.setOperation(AlterOperation.PARTITION_BY); }
        <K_RANGE> { alterExp.setPartitionType("RANGE"); }
        (
            "(" exp=Expression() ")" { alterExp.setPartitionExpression(exp); }
            |
            <K_COLUMNS> columnNames=ColumnsNamesList() { alterExp.setPartitionColumns(columnNames); }
        )
        partitionDefinition=PartitionDefinitions() { alterExp.setPartitionDefinitions(partitionDefinition); }
    )
    { return alterExp; }
}

/**
 * Parses ADD/ALTER/MODIFY operations within ALTER TABLE.
 * Handles: PRIMARY KEY, INDEX/KEY, SPATIAL/FULLTEXT, column COMMENT,
 * ADD PARTITION, column definitions, UNIQUE, FOREIGN KEY, CHECK ENFORCED, CONSTRAINT.
 */
AlterExpression AlterExpressionAddAlterModify():
{
    AlterExpression alterExp = new AlterExpression();
    Token tk;
    Token tk2 = null;
    String sk3 = null;
    String sk4 = null;
    List<String> columnNames = null;
    List<Index.ColumnParams> indexColumnNames = null;
    List<ConstraintState> constraints = null;
    Index index = null;
    AlterExpression.ColumnDataType alterExpressionColumnDataType = null;
    AlterExpression.ColumnDropNotNull alterExpressionColumnDropNotNull = null;
    List<String> indexSpec = new ArrayList<String>();
    List<PartitionDefinition> partitionDefinition = null;
}
{
    (
        <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); }
        [
            AlterExpressionUsingIndex(alterExp)
        ]
        |
        LOOKAHEAD(2) (
          (tk=<K_KEY> { alterExp.setUk(true); } | tk=<K_INDEX>)
          (
              LOOKAHEAD(3)
              sk3 = RelObjectName()
              [ LOOKAHEAD(2) sk4 = UsingIndexType() ]
              [ LOOKAHEAD(2) indexColumnNames = IndexColumnsWithParamsList() ]
              |
              [ LOOKAHEAD(2) sk4 = UsingIndexType() ]
              [ LOOKAHEAD(2) indexColumnNames = IndexColumnsWithParamsList() ]
          )
          IndexOptionList(indexSpec = new ArrayList<String>())
          {
            index = new Index()
                    .withIndexKeyword(tk.image)
                    .withName(sk3)
                    .withUsing(sk4)
                    .withColumns(indexColumnNames)
                    .withIndexSpec(indexSpec);

            alterExp.setIndex(index);
          }
          constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); }
        )
        |
        LOOKAHEAD(4)
        (
          ( tk=<K_SPATIAL> | tk=<K_FULLTEXT> )
          [ LOOKAHEAD(2) ( tk2=<K_INDEX> | tk2=<K_KEY> ) ]
          (
              sk3 = RelObjectName()
              columnNames = ColumnsNamesList()
              |
              columnNames = ColumnsNamesList()
          )
          IndexOptionList(indexSpec = new ArrayList<String>())
          {
              String type = tk.image;
              String keyword = tk2 != null ? tk2.image : null;
              index = new Index()
                  .withType(type)
                  .withIndexKeyword(keyword)
                  .withColumnsNames(columnNames)
                  .withIndexSpec(indexSpec);

              if (sk3 != null) {
                  index.setName(sk3);
              }

              alterExp.setIndex(index);
          }
        )
        |
        LOOKAHEAD(2) (
          sk3=RelObjectName() <K_COMMENT> tk=<S_CHAR_LITERAL> { alterExp.withColumnName(sk3).withCommentText(tk.image); }
        )
        |
        LOOKAHEAD(3) (
            <K_PARTITION> {
                alterExp.setOperation(AlterOperation.ADD_PARTITION);
            }
            partitionDefinition=PartitionDefinitions() {
                alterExp.setPartitionDefinitions(partitionDefinition);
            }
        )
        |
        LOOKAHEAD(3) (
            ( LOOKAHEAD(2)
                (
                    <K_COLUMN> { alterExp.hasColumn(true); }
                    |
                    <K_COLUMNS> { alterExp.hasColumns(true); }
                )
            )?
            [ LOOKAHEAD(2) <K_IF> <K_NOT> <K_EXISTS> { alterExp.setUseIfNotExists(true); } ]
            (
                LOOKAHEAD(3) AlterExpressionColumnChanges(alterExp)
                |
                LOOKAHEAD(2) alterExpressionColumnDataType = AlterExpressionColumnDataType()
                    { alterExp.addColDataType(alterExpressionColumnDataType); }
                |
                LOOKAHEAD(3) alterExpressionColumnDropNotNull = AlterExpressionColumnDropNotNull()
                    { alterExp.addColDropNotNull( alterExpressionColumnDropNotNull);}
            )
        )
        |
        LOOKAHEAD(3) AlterExpressionColumnChanges(alterExp)
        |
        (
            <K_UNIQUE>
            (
                (
                    <K_KEY> { alterExp.setUk(true); }
                    | <K_INDEX> { alterExp.setUk(false); }
                )
                [ (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) { alterExp.setUkName(tk.image); } ]
                |
                (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) {
                    alterExp.setUkTypeSpecified(false);
                    alterExp.setUkName(tk.image);
                }
            )?
            columnNames=ColumnsNamesList() { alterExp.setUkColumns(columnNames); }
            [
                AlterExpressionUsingIndex(alterExp)
            ]
            [ LOOKAHEAD(2) index = IndexWithComment(index) { alterExp.setIndex(index); } ]
        )
        |
        // Standalone FK now uses ForeignKeyIndex, same as CONSTRAINT FK
        (
            { ForeignKeyIndex fkIndex; ReferentialAction ra; }
            fkIndex = ForeignKeySpec(null)
            {
                alterExp.setIndex(fkIndex);
                // backward compat: populate deprecated FK fields from ForeignKeyIndex
                alterExp.setFkColumns(fkIndex.getColumnsNames());
                if (fkIndex.getTable() != null) {
                    alterExp.setFkSourceSchema(fkIndex.getTable().getSchemaName());
                    alterExp.setFkSourceTable(fkIndex.getTable().getName());
                }
                alterExp.setFkSourceColumns(fkIndex.getReferencedColumnNames());
                ra = fkIndex.getReferentialAction(ReferentialAction.Type.DELETE);
                if (ra != null) { alterExp.setReferentialAction(ra.getType(), ra.getAction()); }
                ra = fkIndex.getReferentialAction(ReferentialAction.Type.UPDATE);
                if (ra != null) { alterExp.setReferentialAction(ra.getType(), ra.getAction()); }
            }
        )
        |
        LOOKAHEAD(3) (
            <K_CHECK> sk3=RelObjectName()
            { boolean enforced = true; }
            [ tk = <K_NOT> { enforced = false; } ]
            <K_ENFORCED> {
                alterExp.setEnforced(enforced);
                alterExp.setConstraintType("CHECK");
                alterExp.setConstraintSymbol(sk3);
            }
        )
        |
        (
            AlterExpressionAddConstraint(alterExp)
        )
    )
    { return alterExp; }
}

/**
 * Parses all RENAME variants within ALTER TABLE.
 * Handles: RENAME [COLUMN] old TO new, RENAME TO tablename,
 * RENAME INDEX/KEY/CONSTRAINT old TO new.
 */
AlterExpression AlterExpressionRenameOp():
{
    AlterExpression alterExp = new AlterExpressionRename();
    Token tk;
    Token tk2;
    Index index;
}
{
    <K_RENAME>
    (
        LOOKAHEAD(2) (
            (
                <K_INDEX> { alterExp.setOperation(AlterOperation.RENAME_INDEX); }
                | <K_KEY> { alterExp.setOperation(AlterOperation.RENAME_KEY); }
            )
            |
            <K_CONSTRAINT> { alterExp.setOperation(AlterOperation.RENAME_CONSTRAINT); }
        )
        (tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER>) {
            alterExp.setOldIndex(new Index().withName(tk.image));
        }
        <K_TO>
        (tk2=<S_IDENTIFIER> | tk2=<S_QUOTED_IDENTIFIER>) {
            index = new Index().withName(tk2.image);
            alterExp.setIndex(index);
        }
        |
        LOOKAHEAD(2) (
            <K_TO> { alterExp.setOperation(AlterOperation.RENAME_TABLE); }
            (tk2=<S_IDENTIFIER> | tk2=<S_QUOTED_IDENTIFIER>) { alterExp.setNewTableName(tk2.image); }
        )
        |
        (
            { alterExp.setOperation(AlterOperation.RENAME); }
            [ <K_COLUMN> { alterExp.hasColumn(true); } ]
            (tk=KeywordOrIdentifier()) { alterExp.setColOldName(tk.image); }
            <K_TO>
            (tk2=KeywordOrIdentifier()) { alterExp.setColumnName(tk2.image); }
        )
    )
    { return alterExp; }
}

/**
* Dispatcher production for all ALTER TABLE expression types.
* Delegates to focused sub-productions for each operation category.
*/
AlterExpression AlterExpression():
{
    AlterExpression alterExp = null;
    Token tk;
    Token tk2 = null;
    String sk3 = null;

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

    (
        alterExp = AlterExpressionAddAlterModify()
      |
      (
        { alterExp = new AlterExpression(); }
        <K_CHANGE> { alterExp.setOperation(AlterOperation.CHANGE); }
        [ <K_COLUMN> { alterExp.hasColumn(true); alterExp.setOptionalSpecifier("COLUMN"); } ]
        (
          { AlterExpression.ColumnDataType alterExpressionColumnDataType; }
          (tk=KeywordOrIdentifier())
          alterExpressionColumnDataType = AlterExpressionColumnDataType() {  alterExp.withColumnOldName(tk.image).addColDataType(alterExpressionColumnDataType); }
        )
      )
      |
        alterExp = AlterExpressionDrop()
      |
        LOOKAHEAD(5) (
            { alterExp = new AlterExpression(); }
            <K_FORCE> <K_ROW> <K_LEVEL> <K_SECURITY> {
                alterExp.setOperation(AlterOperation.FORCE_ROW_LEVEL_SECURITY);
            }
        )
      |
        LOOKAHEAD(5) (
            { alterExp = new AlterExpression(); }
            <K_NO> <K_FORCE> <K_ROW> <K_LEVEL> <K_SECURITY> {
                alterExp.setOperation(AlterOperation.NO_FORCE_ROW_LEVEL_SECURITY);
            }
        )
      |
        LOOKAHEAD(1) (
            { alterExp = new AlterExpression(); }
            <K_FORCE>{ alterExp.setOperation(AlterOperation.FORCE); }
        )
      |
        (
         { alterExp = new AlterExpressionTableOption(); }
         <K_ALGORITHM> { alterExp.setOperation(AlterOperation.ALGORITHM); }
         ["=" { alterExp.setUseEqual(true);} ]
         sk3 = RelObjectName() { alterExp.setAlgorithmOption(sk3); }
        )
      |
        (
         { alterExp = new AlterExpressionTableOption(); }
         <K_KEY_BLOCK_SIZE> { alterExp.setOperation(AlterOperation.KEY_BLOCK_SIZE); }
         ["=" { alterExp.setUseEqual(true);} ]
         tk=<S_LONG> { alterExp.setKeyBlockSize(Integer.parseInt(tk.image)); }
        )
      |
        (
         { alterExp = new AlterExpressionTableOption(); }
         <K_LOCK> { alterExp.setOperation(AlterOperation.LOCK); }
         ["=" { alterExp.setUseEqual(true);} ]
         sk3 = RelObjectName() { alterExp.setLockOption(sk3); }
        )
      |
        (
         { alterExp = new AlterExpressionTableOption(); }
         <K_ENGINE> { alterExp.setOperation(AlterOperation.ENGINE); }
         ["=" { alterExp.setUseEqual(true);} ]
         sk3 = RelObjectName() { alterExp.setEngineOption(sk3); }
        )
      |
        LOOKAHEAD(2) alterExp = AlterExpressionRenameOp()
      |
        ({ alterExp = new AlterExpressionCharset(); }
        <K_CONVERT> {
          alterExp.setOperation(AlterOperation.CONVERT);
          alterExp.setConvertType(AlterExpression.ConvertType.CONVERT_TO);
        }
        <K_TO> <K_CHARACTER> <K_SET> tk=<S_IDENTIFIER> { alterExp.setCharacterSet(tk.image); }
        [<K_COLLATE> tk2=<S_IDENTIFIER> { alterExp.setCollation(tk2.image); }]
        )
      |
        LOOKAHEAD(3)
        (
          { alterExp = new AlterExpressionCharset(); }
          <K_DEFAULT>
          (
              <K_CHARACTER> <K_SET> [ "=" { alterExp.setHasEqualForCharacterSet(true); } ]
              tk=<S_IDENTIFIER> {
                  alterExp.setOperation(AlterOperation.CONVERT);
                  alterExp.setConvertType(AlterExpression.ConvertType.DEFAULT_CHARACTER_SET);
                  alterExp.setCharacterSet(tk.image);
              }
              [<K_COLLATE> [ "=" { alterExp.setHasEqualForCollate(true); } ]
                  tk2=<S_IDENTIFIER> { alterExp.setCollation(tk2.image); }]
          |
              <K_COLLATE>
              [ "=" { alterExp.setHasEqualForCollate(true); } ]
              tk=<S_IDENTIFIER> {
                  alterExp.setOperation(AlterOperation.COLLATE);
                  alterExp.setCollation(tk.image);
                  alterExp.setDefaultCollateSpecified(true);
              }
          )
        )
      |
        ({ alterExp = new AlterExpressionCharset(); }
        <K_CHARACTER> <K_SET> [ "=" { alterExp.setHasEqualForCharacterSet(true); } ]
        tk=<S_IDENTIFIER> {
          alterExp.setOperation(AlterOperation.CONVERT);
          alterExp.setConvertType(AlterExpression.ConvertType.CHARACTER_SET);
          alterExp.setCharacterSet(tk.image);
        }
        [<K_COLLATE> [ "=" { alterExp.setHasEqualForCollate(true); } ]
            tk2=<S_IDENTIFIER> { alterExp.setCollation(tk2.image); }]
        )
      |
        ({ alterExp = new AlterExpressionCharset(); }
        <K_COLLATE> { alterExp.setOperation(AlterOperation.COLLATE); }
        [ "=" { alterExp.setHasEqualForCollate(true); } ]
        tk=<S_IDENTIFIER> { alterExp.setCollation(tk.image); }
        )
      |
        ({ alterExp = new AlterExpressionTableOption(); }
        <K_COMMENT> {alterExp.setOperation(AlterOperation.COMMENT);}
            ["=" {alterExp.setOperation(AlterOperation.COMMENT_WITH_EQUAL_SIGN);} ]
            tk=<S_CHAR_LITERAL> { alterExp.setCommentText(tk.image); }
        )
      |
        ({ alterExp = new AlterExpressionTableOption(); }
        <K_ENCRYPTION> {alterExp.setOperation(AlterOperation.SET_TABLE_OPTION);}
            ["=" { alterExp.setUseEqual(true);} ]
            tk=<S_CHAR_LITERAL> {
                if (alterExp.getUseEqual()) {
                    alterExp.setTableOption("ENCRYPTION = " + tk.image);
                } else {
                    alterExp.setTableOption("ENCRYPTION " + tk.image);
                }
            }
        )
      |
        alterExp = AlterExpressionDiscardOrImport()
      |
        LOOKAHEAD(4) (
            { alterExp = new AlterExpression(); }
            <K_DISABLE> <K_ROW> <K_LEVEL> <K_SECURITY> {
                alterExp.setOperation(AlterOperation.DISABLE_ROW_LEVEL_SECURITY);
            }
        )
      |
        LOOKAHEAD(2) (
            { alterExp = new AlterExpressionTableOption(); }
            <K_DISABLE> <K_KEYS> {
                alterExp.setOperation(AlterOperation.DISABLE_KEYS);
            }
        )
      |
        LOOKAHEAD(4) (
            { alterExp = new AlterExpression(); }
            <K_ENABLE> <K_ROW> <K_LEVEL> <K_SECURITY> {
                alterExp.setOperation(AlterOperation.ENABLE_ROW_LEVEL_SECURITY);
            }
        )
      |
        LOOKAHEAD(2) (
            { alterExp = new AlterExpressionTableOption(); }
            <K_ENABLE> <K_KEYS> {
                alterExp.setOperation(AlterOperation.ENABLE_KEYS);
            }
        )
      |
        ({ alterExp = new AlterExpressionTableOption(); }
        <K_AUTO_INCREMENT> {alterExp.setOperation(AlterOperation.SET_TABLE_OPTION);}
            ["=" { alterExp.setUseEqual(true);} ]
            tk=<S_LONG> {
                if (alterExp.getUseEqual()) {
                    alterExp.setTableOption("AUTO_INCREMENT = " + tk.image);
                } else {
                    alterExp.setTableOption("AUTO_INCREMENT " + tk.image);
                }
            }
        )
      |
        alterExp = AlterExpressionPartitionOp()
      |
        { alterExp = new AlterExpression(); }
        tokens = captureRest() {
                    alterExp.setOperation(AlterOperation.UNSPECIFIC);
                    StringBuilder optionalSpecifier = new StringBuilder();
                    int i=0;

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

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

    {
        return alterExp;
    }
}
Statement Alter():
{
    Statement statement;
    List<String> captureRest;
}
{
    (
        (
            <K_ALTER>
            (
                statement = AlterTable()
                |
                statement = AlterSession()
                |
                statement = AlterView(false)
                |
                statement = AlterSystemStatement()
                |
                statement = AlterSequence()
                |
                captureRest = captureRest()
                {
                    statement = new UnsupportedStatement("ALTER", captureRest);
                }
            )
        )
        |
        (
            <K_REPLACE>
            (
                statement = AlterView(true)
                |
                captureRest = captureRest()
                {
                    statement = new UnsupportedStatement("REPLACE", captureRest);
                }
            )
        )
    )
    {
        return statement;
    }
}

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

    alterExp=AlterExpression() { alter.addAlterExpression(alterExp); }

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

    {
        return alter;
    }
}

AlterSession AlterSession():
{
    AlterSessionOperation operation = null;
    List<String> parameters = new ArrayList<String>();
    Token token;
}
{
    <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_SYSTEM> (
        (
           <K_ARCHIVE> <K_LOG> { operation = AlterSystemOperation.ARCHIVE_LOG; }
        )
        |
        (
            <K_CHECKPOINT> { operation = AlterSystemOperation.CHECKPOINT; }
        )
        |
        (
            <K_DUMP> <K_ACTIVE> <K_SESSION> <K_HISTORY> { operation = AlterSystemOperation.DUMP_ACTIVE_SESSION_HISTORY; }
        )
        |
        (
            <K_ENABLE>  (
                            "DISTRIBUTED" "RECOVERY" { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; }
                            | <K_RESTRICTED> <K_SESSION> { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; }
                        )
        )
        |
        (
            <K_DISABLE> (
                            "DISTRIBUTED" "RECOVERY" { operation = AlterSystemOperation.DISABLE_DISTRIBUTED_RECOVERY; }
                            | <K_RESTRICTED> <K_SESSION> { operation = AlterSystemOperation.DISABLE_RESTRICTED_SESSION; }
                        )
        )
        |
        (
            <K_FLUSH> { operation = AlterSystemOperation.FLUSH; }
        )
        |
        (
            <K_DISCONNECT> <K_SESSION> { operation = AlterSystemOperation.DISCONNECT_SESSION; }
        )
        |
        (
            <K_KILL> <K_SESSION> { operation = AlterSystemOperation.KILL_SESSION; }
        )
        |
        (
            <K_SWITCH> { operation = AlterSystemOperation.SWITCH; }
        )
        |
        (
            <K_SUSPEND> { operation = AlterSystemOperation.SUSPEND; }
        )
        |
        (
            <K_RESUME> { operation = AlterSystemOperation.RESUME; }
        )
        |
        (
            <K_QUIESCE> <K_RESTRICTED> { operation = AlterSystemOperation.QUIESCE; }
        )
        |
        (
            <K_UNQIESCE> { operation = AlterSystemOperation.UNQUIESCE; }
        )
        |
        (
            <K_SHUTDOWN> { operation = AlterSystemOperation.SHUTDOWN; }
        )
        |
        (
            <K_REGISTER> { operation = AlterSystemOperation.REGISTER; }
        )
        |
        (
            <K_SET> { operation = AlterSystemOperation.SET; }
        )
        |
        (
            <K_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;
    ObjectNames objName;
}
{
	<K_GRANT>
	(
	    (
            [readGrantTypes(privileges) (<K_COMMA> readGrantTypes(privileges))*]
            <K_ON> objName=RelObjectNames()   { grant.setObjectName(objName.getNames()); }
        )
        |
        (
            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 :
{
    ObjectNames data = null;
    String serverName = null, databaseName = null, schemaName = null, sequenceName = null;
}
{
    data = RelObjectNames()
    {
        Sequence sequence = new Sequence(data.getNames());
		linkAST(sequence,jjtThis);
        return sequence;
    }
}

List<Sequence.Parameter> SequenceParameters():
{
  List<Sequence.Parameter> sequenceParameters = new ArrayList<Sequence.Parameter>();
  Sequence.Parameter parameter = null;
  Token token = null;
  Token byToken = null;
  Token withToken = null;
}
{
    (
        LOOKAHEAD(2) (
            (
                <K_INCREMENT> [ byToken=<K_BY> ] token=<S_LONG>
                {
                    if (byToken != null) {
                      parameter = new Sequence.Parameter(Sequence.ParameterType.INCREMENT_BY);
                    } else {
                      parameter = new Sequence.Parameter(Sequence.ParameterType.INCREMENT);
                    }
                    parameter.setValue(Long.parseLong(token.image));
                    sequenceParameters.add(parameter);
                }
           )
           |
           (
                <K_START> [ withToken=<K_WITH> ] token=<S_LONG>
                {
                    if (withToken != null) {
                        parameter = new Sequence.Parameter(Sequence.ParameterType.START_WITH);
                    } else {
                        parameter = new Sequence.Parameter(Sequence.ParameterType.START);
                    }
                    parameter.setValue(Long.parseLong(token.image));
                    sequenceParameters.add(parameter);
                }
            )
            |
            (
                <K_RESTART> [ LOOKAHEAD(2) <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)); }
        )
    )*
    {
        return sequenceParameters;
    }
}

CreateSequence CreateSequence():
{
  CreateSequence createSequence = new CreateSequence();
  Sequence sequence;
  List<Sequence.Parameter> sequenceParameters;
  Token dataType = null;
}
{
  <K_SEQUENCE> sequence=Sequence() { createSequence.setSequence(sequence); }
  [ <K_AS> ( dataType=<S_IDENTIFIER> | dataType=<DATA_TYPE> ) { sequence.setDataType(dataType.image); } ]
  sequenceParameters = SequenceParameters()
    {
        sequence.setParameters(sequenceParameters);
        return createSequence;
    }
}

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

Statement Create():
{
    boolean isUsingOrReplace=false;
    Token tk;
    Statement statement;
    List<String> captureRest;
}
{
    <K_CREATE> [ <K_OR> <K_REPLACE> { isUsingOrReplace = true; } ]
    (
        statement = CreateFunctionStatement(isUsingOrReplace)
        |
        statement = CreateSchema()
        |
        statement = CreateDatabase()
        |
        statement = CreateSequence()
        |
        statement = CreateSynonym(isUsingOrReplace)
        |
        LOOKAHEAD(3) statement = CreateTable(isUsingOrReplace)
        |
        LOOKAHEAD(2) statement = CreateView(isUsingOrReplace)
        |
        statement = CreatePolicy()
        |
        // @fixme: must appear with TRIGGER before INDEX or it will collide with INDEX's CreateParameter() production
        ( tk=<K_TRIGGER> | tk=<K_DOMAIN> ) captureRest = captureRest()
        {
            statement = new UnsupportedStatement("CREATE " + tk.image, captureRest);
        }
        |
        /* @fixme
         *  Create Index uses CreateParameter() which allows all kind of tokens
         *  it can conflict with other statements and must be at the end right now
         */
        statement = CreateIndex()
        |
        captureRest = captureRest()
        {
            statement = new UnsupportedStatement("CREATE", captureRest);
        }
    )
    {
        return statement;
    }
}

CreateFunctionalStatement CreateFunctionStatement(boolean isUsingOrReplace):
{
  CreateFunctionalStatement type = null;
  List<String> tokens = new LinkedList<String>();
  String statementType = null;
}
{
  (
   <K_FUNCTION> { statementType = "FUNCTION"; }
   |
   <K_PROCEDURE> { statementType = "PROCEDURE"; }
  )
  tokens=captureFunctionBody()
  {
    if(statementType.equals("FUNCTION")) {
      type = new CreateFunction(isUsingOrReplace, tokens);
    }
    if(statementType.equals("PROCEDURE")) {
      type = new CreateProcedure(isUsingOrReplace, tokens);
    }

    return type;
  }
}

CreateSynonym CreateSynonym(boolean isUsingOrReplace):
{
  CreateSynonym createSynonym = new CreateSynonym();
  Synonym synonym;
  boolean publicSynonym = false;
  ObjectNames data = null;
}
{
  [<K_PUBLIC> { publicSynonym = true; } ]
  <K_SYNONYM> synonym=Synonym() { createSynonym.setSynonym(synonym); }
  <K_FOR> data = RelObjectNames()
  {
    createSynonym.setOrReplace(isUsingOrReplace);
    createSynonym.setPublicSynonym(publicSynonym);
    createSynonym.setForList(data.getNames());
    return createSynonym;
  }
}

Synonym Synonym() #Synonym :
{
    ObjectNames data = null;
    String serverName = null, databaseName = null, schemaName = null, sequenceName = null;
}
{
    data = RelObjectNames()
    {
        Synonym synonym = new Synonym(data.getNames());
		linkAST(synonym,jjtThis);
        return synonym;
    }
}

CreatePolicy CreatePolicy() #CreatePolicy:
{
    CreatePolicy createPolicy = new CreatePolicy();
    String policyName;
    Table table;
    Token commandToken = null;
    String roleName;
    Expression usingExpr = null;
    Expression checkExpr = null;
}
{
    <K_POLICY> policyName=RelObjectName() { createPolicy.setPolicyName(policyName); }
    <K_ON> table=Table() { createPolicy.setTable(table); }

    [ <K_FOR>
      ( commandToken=<K_ALL>
      | commandToken=<K_SELECT>
      | commandToken=<K_INSERT>
      | commandToken=<K_UPDATE>
      | commandToken=<K_DELETE>
      )
      { createPolicy.setCommand(commandToken.image); }
    ]

    [ <K_TO>
      roleName=RelObjectName() { createPolicy.addRole(roleName); }
      ( "," roleName=RelObjectName() { createPolicy.addRole(roleName); } )*
    ]

    [ <K_USING> "(" usingExpr=Expression() ")" { createPolicy.setUsingExpression(usingExpr); } ]

    [ LOOKAHEAD(2) <K_WITH> <K_CHECK> "(" checkExpr=Expression() ")" { createPolicy.setWithCheckExpression(checkExpr); } ]

    {

        return createPolicy;
    }
}

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);
    int l = tokens.size();
    if( tok.kind == EOF || tok.kind == ST_SEMICOLON ) {
      break;
    } else if ( l>0 && ( tok.image.equals(".") ||  tokens.get(l-1).endsWith(".")) ) {
        tokens.set(l-1, tokens.get(l-1) + tok.image);
    } else {
        tokens.add(tok.image);
    }
    tok = getNextToken();
  }
  return tokens;
}

/**
* Reads the tokens of a function or procedure body.
* A function body can end in 2 ways:
* 1) BEGIN...END;
* 2) Postgres: $$...$$...;
*/

JAVACODE
List<String> captureFunctionBody() {
  List<String> tokens = new LinkedList<String>();
  Token tok;
  boolean foundEnd = false;
  while(true) {
    tok = getToken(1);
    int l = tokens.size();
    if( tok.kind == EOF || ( foundEnd && tok.kind == ST_SEMICOLON) ) {
      if (tok.kind == ST_SEMICOLON) {
        tokens.add(tok.image);
      }
      break;
    } else if ( l>0 && ( tok.image.equals(".") ||  tokens.get(l-1).endsWith(".")) ) {
        tokens.set(l-1, tokens.get(l-1) + tok.image);
    } else {
        tokens.add(tok.image);
    }
    foundEnd |= (tok.kind == K_END)
        || ( tok.image.trim().startsWith("$$") && tok.image.trim().endsWith("$$")) ;

    tok = getNextToken();
  }
  return tokens;
}

/**
* Reads the tokens of a Postgres dollar quoted string,
  rebuilding the white space of the text based on each token's position and length
    1) $$...$$
    2) $tag$...$tag$
*/

JAVACODE
String getQuotedString(String closingQuote, String escapeChar) {
    StringBuilder buffer = new StringBuilder();
    Deque<Character> windowQueue = new ArrayDeque<Character>();
    int delimiterLength = closingQuote.length();

    Token prevToken = null;
    Token token;

    while (true) {
        token = getNextToken();
        if (token.kind == 0) {
            throw new ParseException("Unterminated quoted string");
        }
        appendWhitespaceFromTokenGap(buffer, prevToken, token);
        appendTokenImageAndTrackDelimiter(buffer, windowQueue, delimiterLength, token.image, closingQuote);
        if (endsWithDelimiter(windowQueue, closingQuote)) {
            buffer.setLength(buffer.length() - delimiterLength);
            return buffer.toString();
        }
        prevToken = token;
    }
}

JAVACODE
String getQuotedIdentifier(String openingQuote, String closingQuote, String escapeChar) {
    return openingQuote + getQuotedString(closingQuote, escapeChar) + closingQuote;
}


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;
}

String IdentifierChain():
{
    String identifierChain;
    String part;
}
{
    identifierChain=RelObjectNameExt()
    ( LOOKAHEAD(2) "." part=RelObjectNameExt() { identifierChain += "." + part; }  )*

    {
        return identifierChain;
    }
}

String IdentifierChain2(String identifierChain):
{
    String part;
}
{
    ( LOOKAHEAD(2) "." part=RelObjectNameExt() { identifierChain += "." + part; }  )*
    {
        return identifierChain;
    }
}

Expression CharacterPrimary():
{
    Expression expression;
}
{
    (
        expression = TranscodingFunction()
        |
        expression = TrimFunction()
    )
    // @todo
    // @see https://manticore-projects.com/SQL2016Parser/syntax.html#character-value-function
    //  | character_substring_function
    //  | regular_expression_substring_function
    //  | regex_substring_function
    //  | fold
    //  | character_transliteration
    //  | regex_transliteration
    //  | character_overlay_function
    //  | normalize_function
    //  | specific_type_method

    {
        return expression;
    }
}

TranscodingFunction TranscodingFunction() #TranscodingFunction :
{
    Token keywordToken;
    TranscodingFunction transcodingFunction;
    ColDataType colDataType;
    Expression expression;
    String transcodingName=null;
    Token style;
}
{
    ( keywordToken=<K_TRY_CONVERT> | keywordToken=<K_SAFE_CONVERT> | keywordToken=<K_CONVERT> )
    "("
    (
        LOOKAHEAD(4) colDataType = ColDataType()
        "," expression = Expression()
        [ "," style = <S_LONG> { transcodingName = style.image; } ]

        {
            transcodingFunction = new TranscodingFunction(keywordToken.image, colDataType, expression, transcodingName);
        }
        |
        (
            expression = Expression()
            <K_USING> transcodingName=IdentifierChain()

            {
                transcodingFunction = new TranscodingFunction(expression, transcodingName);
            }
        )
    )
    ")"
    {
        return transcodingFunction;
    }
}

TrimFunction TrimFunction():
{
    TrimFunction.TrimSpecification trimSpecification=null;
    Expression expression = null;
    boolean usesFrom = false;
    Expression fromExpression = null;
}
{
    <K_TRIM> "("
    [
        LOOKAHEAD(2) (
            <K_LEADING> { trimSpecification = TrimFunction.TrimSpecification.LEADING; }
            |
            <K_TRAILING> { trimSpecification = TrimFunction.TrimSpecification.TRAILING; }
            |
            <K_BOTH> { trimSpecification = TrimFunction.TrimSpecification.BOTH; }
        )
    ]

    // This is not SQL:2016 compliant, but Postgres supports it
    [ expression = Expression() ]

    [
        (
            ","
            |
            <K_FROM> { usesFrom = true; }
        )
        fromExpression = Expression()
    ]
    ")"

    {
        return new TrimFunction(trimSpecification, expression, fromExpression, usesFrom);
    }
}

void SnowflakeTimeTravelAt(StringBuilder builder):
{
    Expression expression;
    Token tk;
}
{
    // AT( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> | STREAM => '<name>' } )

    <K_AT> <OPENING_BRACKET> { builder.append("AT ("); }
    (
        //@fixme: this should be TIMESTAMP only but JavaCC-8 has issues with compound tokens!
        <K_DATETIMELITERAL> "=>" expression = Expression()
        { builder.append( "TIMESTAMP => ").append(expression.toString()); }
        |
        <K_OFFSET> "=>" expression = Expression()
        { builder.append( "OFFSET => ").append(expression.toString()); }
        |
        <K_STATEMENT> "=>" ( tk=<S_CHAR_LITERAL>| tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER> )
        { builder.append( "STATEMENT => ").append(tk.image); }
        |
        <K_STREAM> "=>" tk=<S_CHAR_LITERAL>
        { builder.append( "STREAM => ").append(tk.image); }
    )
    <CLOSING_BRACKET> { builder.append(")"); }
}


void SnowflakeTimeTravelBefore(StringBuilder builder):
{
    Expression expression;
    Token tk;
}
{
    // BEFORE( STATEMENT => <id> )

    <K_BEFORE> <OPENING_BRACKET> { builder.append("BEFORE ("); }
    <K_STATEMENT> "=>" ( tk=<S_CHAR_LITERAL>| tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER> )
    { builder.append( "STATEMENT => ").append(tk.image); }
    <CLOSING_BRACKET> { builder.append(")"); }
}

void SnowflakeTimeTravelChange(StringBuilder builder):
{
    Expression expression;
    Token tk;
}
{
    /*
    CHANGES ( INFORMATION => { DEFAULT | APPEND_ONLY } )
       AT ( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> | STREAM => '<name>' } )
       |
       BEFORE ( STATEMENT => <id> )
       [ END( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> } ) ]
     */

     <K_CHANGES> <OPENING_BRACKET> <K_INFORMATION> "=>"
     { builder.append("CHANGES (INFORMATION => ");}

     ( tk = <K_DEFAULT> | tk=<K_APPEND_ONLY>)
     { builder.append(tk.image); }

     <CLOSING_BRACKET> { builder.append(") "); }

     (
         SnowflakeTimeTravelAt(builder)
         |
         SnowflakeTimeTravelBefore(builder)
     )

     [
        LOOKAHEAD(2) <K_END> <OPENING_BRACKET>
        { builder.append(" END ("); }

        (
            //@fixme: this should be TIMESTAMP only but JavaCC-8 has issues with compound tokens!
            <K_DATETIMELITERAL> "=>" expression = Expression()
            { builder.append( "TIMESTAMP => ").append(expression.toString()); }
            |
            <K_OFFSET> "=>" expression = Expression()
            { builder.append( "OFFSET => ").append(expression.toString()); }
            |
            <K_STATEMENT> "=>" ( tk=<S_CHAR_LITERAL>| tk=<S_IDENTIFIER> | tk=<S_QUOTED_IDENTIFIER> )
            { builder.append( "STATEMENT => ").append(tk.image); }
        )

        <CLOSING_BRACKET> { builder.append(")"); }
     ]
}

void DataBricksTemporalSpec(StringBuilder builder):
{
    Token tk;
    Expression expression;
}
{
    /*
    temporal_spec https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-names#syntax-3
    {
      @ timestamp_encoding |
      @V version |
      [ FOR ] { SYSTEM_TIMESTAMP | TIMESTAMP } AS OF timestamp_expression |
      [ FOR ] { SYSTEM_VERSION | VERSION } AS OF version
    }
     */
    (tk=<K_AT_SIGN> | tk=<K_AT_V>)  { builder.append(tk.image).append(" "); }
    (tk=<S_CHAR_LITERAL> | tk=<S_LONG>) { builder.append(tk.image); }
    |
    [ <K_FOR> { builder.append(" FOR"); } ]

    ( tk=<K_SYSTEM_TIMESTAMP> | tk=<K_DATETIMELITERAL> )
    <K_AS> <K_OF> expression=Expression()
    { builder.append(" ").append(tk.image).append(" AS OF ").append(expression.toString()); }
    |
    (
        ( tk=<K_SYSTEM_VERSION> | tk= <K_VERSION>) { builder.append(" ").append(tk.image); }
        <K_AS> <K_OF> (tk=<S_LONG> | tk=<S_CHAR_LITERAL> ) { builder.append(" AS OF ").append(tk.image); }
    )
}

void BigQueryHistoricalVersion(StringBuilder builder):
{
    Token tk;
    Expression expression;
}
{
    /*
    FOR SYSTEM_TIME AS OF timestamp_expression
     */
    <K_FOR> <K_SYSTEM_TIME> <K_AS> <K_OF> expression=Expression()
    { builder.append(" FOR SYSTEM_TIME AS OF ").append(expression.toString()); }
}

String TimeTravelBeforeAlias():
{
    StringBuilder builder = new StringBuilder();
}
{
    (
        SnowflakeTimeTravelAt(builder)
        |
        SnowflakeTimeTravelBefore(builder)
        |
        SnowflakeTimeTravelChange(builder)
        |
        DataBricksTemporalSpec(builder)
    )

    {
        return builder.toString();
    }
}

String TimeTravelAfterAlias():
{
    StringBuilder builder = new StringBuilder();
}
{
    BigQueryHistoricalVersion(builder)
    {
        return builder.toString();
    }
}