• Home
• com.linkedin.calcite
• calcite-babel
• 1.21.0.151
• source code
• SqlBabelParserImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.apache.calcite.sql.parser.babel.SqlBabelParserImpl Maven / Gradle / Ivy

/* Generated By:JavaCC: Do not edit this line. SqlBabelParserImpl.java */
package org.apache.calcite.sql.parser.babel;


import org.apache.calcite.avatica.util.Casing;
import org.apache.calcite.avatica.util.DateTimeUtils;
import org.apache.calcite.avatica.util.TimeUnit;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.runtime.CalciteContextException;
import org.apache.calcite.sql.JoinConditionType;
import org.apache.calcite.sql.JoinType;
import org.apache.calcite.sql.SqlAlter;
import org.apache.calcite.sql.SqlBasicTypeNameSpec;
import org.apache.calcite.sql.SqlBinaryOperator;
import org.apache.calcite.sql.SqlCall;
import org.apache.calcite.sql.SqlCharStringLiteral;
import org.apache.calcite.sql.SqlCollation;
import org.apache.calcite.sql.SqlCollectionTypeNameSpec;
import org.apache.calcite.sql.SqlDataTypeSpec;
import org.apache.calcite.sql.SqlDateLiteral;
import org.apache.calcite.sql.SqlDelete;
import org.apache.calcite.sql.SqlDescribeSchema;
import org.apache.calcite.sql.SqlDescribeTable;
import org.apache.calcite.sql.SqlDynamicParam;
import org.apache.calcite.sql.SqlExplain;
import org.apache.calcite.sql.SqlExplainFormat;
import org.apache.calcite.sql.SqlExplainLevel;
import org.apache.calcite.sql.SqlFunction;
import org.apache.calcite.sql.SqlFunctionCategory;
import org.apache.calcite.sql.SqlIdentifier;
import org.apache.calcite.sql.SqlInsert;
import org.apache.calcite.sql.SqlInsertKeyword;
import org.apache.calcite.sql.SqlIntervalLiteral;
import org.apache.calcite.sql.SqlIntervalQualifier;
import org.apache.calcite.sql.SqlJdbcDataTypeName;
import org.apache.calcite.sql.SqlJdbcFunctionCall;
import org.apache.calcite.sql.SqlJoin;
import org.apache.calcite.sql.SqlJsonConstructorNullClause;
import org.apache.calcite.sql.SqlJsonEncoding;
import org.apache.calcite.sql.SqlJsonExistsErrorBehavior;
import org.apache.calcite.sql.SqlJsonEmptyOrError;
import org.apache.calcite.sql.SqlJsonQueryEmptyOrErrorBehavior;
import org.apache.calcite.sql.SqlJsonQueryWrapperBehavior;
import org.apache.calcite.sql.SqlJsonValueEmptyOrErrorBehavior;
import org.apache.calcite.sql.SqlKind;
import org.apache.calcite.sql.SqlLiteral;
import org.apache.calcite.sql.SqlMatchRecognize;
import org.apache.calcite.sql.SqlMerge;
import org.apache.calcite.sql.SqlNode;
import org.apache.calcite.sql.SqlNodeList;
import org.apache.calcite.sql.SqlNumericLiteral;
import org.apache.calcite.sql.SqlOperator;
import org.apache.calcite.sql.SqlOrderBy;
import org.apache.calcite.sql.SqlPostfixOperator;
import org.apache.calcite.sql.SqlPrefixOperator;
import org.apache.calcite.sql.SqlRowTypeNameSpec;
import org.apache.calcite.sql.SqlSampleSpec;
import org.apache.calcite.sql.SqlSelect;
import org.apache.calcite.sql.SqlSelectKeyword;
import org.apache.calcite.sql.SqlSetOption;
import org.apache.calcite.sql.SqlSnapshot;
import org.apache.calcite.sql.SqlTimeLiteral;
import org.apache.calcite.sql.SqlTimestampLiteral;
import org.apache.calcite.sql.SqlTypeNameSpec;
import org.apache.calcite.sql.SqlUnnestOperator;
import org.apache.calcite.sql.SqlUpdate;
import org.apache.calcite.sql.SqlUserDefinedTypeNameSpec;
import org.apache.calcite.sql.SqlUtil;
import org.apache.calcite.sql.SqlWindow;
import org.apache.calcite.sql.SqlWith;
import org.apache.calcite.sql.SqlWithItem;
import org.apache.calcite.sql.fun.SqlCase;
import org.apache.calcite.sql.fun.SqlLibraryOperators;
import org.apache.calcite.sql.fun.SqlStdOperatorTable;
import org.apache.calcite.sql.fun.SqlTrimFunction;
import org.apache.calcite.sql.parser.Span;
import org.apache.calcite.sql.parser.SqlAbstractParserImpl;
import org.apache.calcite.sql.parser.SqlParseException;
import org.apache.calcite.sql.parser.SqlParser;
import org.apache.calcite.sql.parser.SqlParserImplFactory;
import org.apache.calcite.sql.parser.SqlParserPos;
import org.apache.calcite.sql.parser.SqlParserUtil;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.sql.validate.SqlConformance;
import org.apache.calcite.util.Glossary;
import org.apache.calcite.util.NlsString;
import org.apache.calcite.util.Pair;
import org.apache.calcite.util.SourceStringReader;
import org.apache.calcite.util.Util;
import org.apache.calcite.util.trace.CalciteTrace;

import org.slf4j.Logger;

import java.io.Reader;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.List;
import java.util.Locale;

import static org.apache.calcite.util.Static.RESOURCE;

/**
 * SQL parser, generated from Parser.jj by JavaCC.
 *
 * 
The public wrapper for this parser is {@link SqlParser}.
 */
public class SqlBabelParserImpl extends SqlAbstractParserImpl implements SqlBabelParserImplConstants {
    private static final Logger LOGGER = CalciteTrace.getParserTracer();

    // Can't use quoted literal because of a bug in how JavaCC translates
    // backslash-backslash.
    private static final char BACKSLASH = 0x5c;
    private static final char DOUBLE_QUOTE = 0x22;
    private static final String DQ = DOUBLE_QUOTE + "";
    private static final String DQDQ = DQ + DQ;

    private static Metadata metadata;

    private Casing unquotedCasing;
    private Casing quotedCasing;
    private int identifierMaxLength;
    private SqlConformance conformance;

    /**
     * {@link SqlParserImplFactory} implementation for creating parser.
     */
    public static final SqlParserImplFactory FACTORY = new SqlParserImplFactory() {
        public SqlAbstractParserImpl getParser(Reader reader) {
            final SqlBabelParserImpl parser = new SqlBabelParserImpl(reader);
            if (reader instanceof SourceStringReader) {
                final String sql =
                    ((SourceStringReader) reader).getSourceString();
                parser.setOriginalSql(sql);
            }
          return parser;
        }
    };

    public SqlParseException normalizeException(Throwable ex) {
        try {
            if (ex instanceof ParseException) {
                ex = cleanupParseException((ParseException) ex);
            }
            return convertException(ex);
        } catch (ParseException e) {
            throw new AssertionError(e);
        }
    }

    public Metadata getMetadata() {
        synchronized (SqlBabelParserImpl.class) {
            if (metadata == null) {
                metadata = new MetadataImpl(
                    new SqlBabelParserImpl(new java.io.StringReader("")));
            }
            return metadata;
        }
    }

    public void setTabSize(int tabSize) {
        jj_input_stream.setTabSize(tabSize);
    }

    public void switchTo(String stateName) {
        int state = Arrays.asList(SqlBabelParserImplTokenManager.lexStateNames)
            .indexOf(stateName);
        token_source.SwitchTo(state);
    }

    public void setQuotedCasing(Casing quotedCasing) {
        this.quotedCasing = quotedCasing;
    }

    public void setUnquotedCasing(Casing unquotedCasing) {
        this.unquotedCasing = unquotedCasing;
    }

    public void setIdentifierMaxLength(int identifierMaxLength) {
        this.identifierMaxLength = identifierMaxLength;
    }

    public void setConformance(SqlConformance conformance) {
        this.conformance = conformance;
    }

    public SqlNode parseSqlExpressionEof() throws Exception {
        return SqlExpressionEof();
    }

    public SqlNode parseSqlStmtEof() throws Exception {
        return SqlStmtEof();
    }

    public SqlNodeList parseSqlStmtList() throws Exception {
        return SqlStmtList();
    }

    private SqlNode extend(SqlNode table, SqlNodeList extendList) {
        return SqlStdOperatorTable.EXTEND.createCall(
            Span.of(table, extendList).pos(), table, extendList);
    }

  void debug_message1() throws ParseException {
    LOGGER.info("{} , {}", getToken(0).image, getToken(1).image);
  }

  String unquotedIdentifier() throws ParseException {
    return SqlParserUtil.strip(getToken(0).image, null, null, null,
        unquotedCasing);
  }

/**
 * Allows parser to be extended with new types of table references.  The
 * default implementation of this production is empty.
 */
  final public SqlNode ExtendedTableRef() throws ParseException {
    UnusedExtension();
        {if (true) return null;}
    throw new Error("Missing return statement in function");
  }

/**
 * Allows an OVER clause following a table expression as an extension to
 * standard SQL syntax. The default implementation of this production is empty.
 */
  final public SqlNode TableOverOpt() throws ParseException {
        {if (true) return null;}
    throw new Error("Missing return statement in function");
  }

/*
 * Parses dialect-specific keywords immediately following the SELECT keyword.
 */
  final public void SqlSelectKeywords(List keywords) throws ParseException {
    E();
  }

/*
 * Parses dialect-specific keywords immediately following the INSERT keyword.
 */
  final public void SqlInsertKeywords(List keywords) throws ParseException {
    E();
  }

/*
* Parse Floor/Ceil function parameters
*/
  final public SqlNode FloorCeilOptions(Span s, boolean floorFlag) throws ParseException {
    SqlNode node;
    node = StandardFloorCeilOptions(s, floorFlag);
        {if (true) return node;}
    throw new Error("Missing return statement in function");
  }

  void E() throws ParseException {
  }

  List startList(Object o) throws ParseException {
    List list = new ArrayList();
    list.add(o);
    return list;
  }

  protected SqlParserPos getPos() throws ParseException {
    return new SqlParserPos(
        token.beginLine,
        token.beginColumn,
        token.endLine,
        token.endColumn);
  }

  Span span() throws ParseException {
    return Span.of(getPos());
  }

  void checkQueryExpression(ExprContext exprContext) throws ParseException {
    switch (exprContext) {
    case ACCEPT_NON_QUERY:
    case ACCEPT_SUB_QUERY:
    case ACCEPT_CURSOR:
        throw SqlUtil.newContextException(getPos(),
            RESOURCE.illegalQueryExpression());
    }
  }

  void checkNonQueryExpression(ExprContext exprContext) throws ParseException {
    switch (exprContext) {
    case ACCEPT_QUERY:
        throw SqlUtil.newContextException(getPos(),
            RESOURCE.illegalNonQueryExpression());
    }
  }

  SqlParseException convertException(Throwable ex) throws ParseException {
    if (ex instanceof SqlParseException) {
        return (SqlParseException) ex;
    }
    SqlParserPos pos = null;
    int[][] expectedTokenSequences = null;
    String[] tokenImage = null;
    if (ex instanceof ParseException) {
        ParseException pex = (ParseException) ex;
        expectedTokenSequences = pex.expectedTokenSequences;
        tokenImage = pex.tokenImage;
        if (pex.currentToken != null) {
            final Token token = pex.currentToken.next;
            pos = new SqlParserPos(
                token.beginLine,
                token.beginColumn,
                token.endLine,
                token.endColumn);
        }
    } else if (ex instanceof TokenMgrError) {
        TokenMgrError tme = (TokenMgrError) ex;
        expectedTokenSequences = null;
        tokenImage = null;
        // Example:
        //    Lexical error at line 3, column 24.  Encountered "#" after "a".
        final java.util.regex.Pattern pattern = java.util.regex.Pattern.compile(
            "(?s)Lexical error at line ([0-9]+), column ([0-9]+).*");
        java.util.regex.Matcher matcher = pattern.matcher(ex.getMessage());
        if (matcher.matches()) {
            int line = Integer.parseInt(matcher.group(1));
            int column = Integer.parseInt(matcher.group(2));
            pos = new SqlParserPos(line, column, line, column);
        }
    } else if (ex instanceof CalciteContextException) {
        // CalciteContextException is the standard wrapper for exceptions
        // produced by the validator, but in the parser, the standard is
        // SqlParseException; so, strip it away. In case you were wondering,
        // the CalciteContextException appears because the parser
        // occasionally calls into validator-style code such as
        // SqlSpecialOperator.reduceExpr.
        CalciteContextException ece =
            (CalciteContextException) ex;
        pos = new SqlParserPos(
            ece.getPosLine(),
            ece.getPosColumn(),
            ece.getEndPosLine(),
            ece.getEndPosColumn());
        ex = ece.getCause();
    }

    return new SqlParseException(
        ex.getMessage(), pos, expectedTokenSequences, tokenImage, ex);
  }

  ParseException cleanupParseException(ParseException ex) throws ParseException {
    if (ex.expectedTokenSequences == null) {
        return ex;
    }
    int iIdentifier = Arrays.asList(ex.tokenImage).indexOf("");

    // Find all sequences in the error which contain identifier. For
    // example,
    //       {}
    //       {A}
    //       {B, C}
    //       {D, }
    //       {D, A}
    //       {D, B}
    //
    // would yield
    //       {}
    //       {D}
    boolean id = false;
    final List prefixList = new ArrayList();
    for (int i = 0; i < ex.expectedTokenSequences.length; ++i) {
        int[] seq = ex.expectedTokenSequences[i];
        int j = seq.length - 1;
        int i1 = seq[j];
        if (i1 == iIdentifier) {
            int[] prefix = new int[j];
            System.arraycopy(seq, 0, prefix, 0, j);
            prefixList.add(prefix);
        }
    }

    if (prefixList.isEmpty()) {
        return ex;
    }

    int[][] prefixes = (int[][])
        prefixList.toArray(new int[prefixList.size()][]);

    // Since  was one of the possible productions,
    // we know that the parser will also have included all
    // of the non-reserved keywords (which are treated as
    // identifiers in non-keyword contexts).  So, now we need
    // to clean those out, since they're totally irrelevant.

    final List list = new ArrayList();
    Metadata metadata = getMetadata();
    for (int i = 0; i < ex.expectedTokenSequences.length; ++i) {
        int [] seq = ex.expectedTokenSequences[i];
        String tokenImage = ex.tokenImage[seq[seq.length - 1]];
        String token = SqlParserUtil.getTokenVal(tokenImage);
        if (token == null  || !metadata.isNonReservedKeyword(token)) {
            list.add(seq);
            continue;
        }
        boolean match = matchesPrefix(seq, prefixes);
        if (!match) {
            list.add(seq);
        }
    }

    ex.expectedTokenSequences =
        (int [][]) list.toArray(new int [list.size()][]);
    return ex;
  }

  boolean matchesPrefix(int[] seq, int[][] prefixes) throws ParseException {
    nextPrefix:
    for (int[] prefix : prefixes) {
        if (seq.length == prefix.length + 1) {
            for (int k = 0; k < prefix.length; k++) {
                if (prefix[k] != seq[k]) {
                    continue nextPrefix;
                }
            }
            return true;
        }
    }
    return false;
  }

/*****************************************
 * Syntactical Descriptions              *
 *****************************************/

/**
 * Parses either a row expression or a query expression with an optional
 * ORDER BY.
 *
 * 
Postgres syntax for limit:
 *
 * 
 *    [ LIMIT { count | ALL } ]
 *    [ OFFSET start ]
 * 
 *
 * 
MySQL syntax for limit:
 *
 * 
 *    [ LIMIT { count | start, count } ]
 * 
 *
 * 
SQL:2008 syntax for limit:
 *
 * 
 *    [ OFFSET start { ROW | ROWS } ]
 *    [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
 * 
 */
  final public SqlNode OrderedQueryOrExpr(ExprContext exprContext) throws ParseException {
    SqlNode e;
    SqlNodeList orderBy = null;
    SqlNode start = null;
    SqlNode count = null;
    e = QueryOrExpr(exprContext);
    if (jj_2_1(2)) {
      // use the syntactic type of the expression we just parsed
              // to decide whether ORDER BY makes sense
              orderBy = OrderBy(e.isA(SqlKind.QUERY));
    } else {
      ;
    }
    if (jj_2_5(2)) {
      jj_consume_token(LIMIT);
      if (jj_2_2(2)) {
        start = UnsignedNumericLiteralOrParam();
        jj_consume_token(COMMA);
        count = UnsignedNumericLiteralOrParam();
                if (!this.conformance.isLimitStartCountAllowed()) {
                    {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.limitStartCountNotAllowed());}
                }
      } else if (jj_2_3(2)) {
        count = UnsignedNumericLiteralOrParam();
      } else if (jj_2_4(2)) {
        jj_consume_token(ALL);
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
    } else {
      ;
    }
    if (jj_2_9(2)) {
      jj_consume_token(OFFSET);
      start = UnsignedNumericLiteralOrParam();
      if (jj_2_8(2)) {
        if (jj_2_6(2)) {
          jj_consume_token(ROW);
        } else if (jj_2_7(2)) {
          jj_consume_token(ROWS);
        } else {
          jj_consume_token(-1);
          throw new ParseException();
        }
      } else {
        ;
      }
    } else {
      ;
    }
    if (jj_2_14(2)) {
      jj_consume_token(FETCH);
      if (jj_2_10(2)) {
        jj_consume_token(FIRST);
      } else if (jj_2_11(2)) {
        jj_consume_token(NEXT);
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      count = UnsignedNumericLiteralOrParam();
      if (jj_2_12(2)) {
        jj_consume_token(ROW);
      } else if (jj_2_13(2)) {
        jj_consume_token(ROWS);
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(ONLY);
    } else {
      ;
    }
        if (orderBy != null || start != null || count != null) {
            if (orderBy == null) {
                orderBy = SqlNodeList.EMPTY;
            }
            e = new SqlOrderBy(getPos(), e, orderBy, start, count);

        }
        {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

/**
 * Parses a leaf in a query expression (SELECT, VALUES or TABLE).
 */
  final public SqlNode LeafQuery(ExprContext exprContext) throws ParseException {
    SqlNode e;
    if (jj_2_15(2)) {
        // ensure a query is legal in this context
        checkQueryExpression(exprContext);
      e = SqlSelect();
                      {if (true) return e;}
    } else if (jj_2_16(2)) {
      e = TableConstructor();
                             {if (true) return e;}
    } else if (jj_2_17(2)) {
      e = ExplicitTable(getPos());
                                  {if (true) return e;}
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

/**
 * Parses a parenthesized query or single row expression.
 */
  final public SqlNode ParenthesizedExpression(ExprContext exprContext) throws ParseException {
    SqlNode e;
    jj_consume_token(LPAREN);
        // we've now seen left paren, so queries inside should
        // be allowed as sub-queries
        switch (exprContext) {
        case ACCEPT_SUB_QUERY:
            exprContext = ExprContext.ACCEPT_NONCURSOR;
            break;
        case ACCEPT_CURSOR:
            exprContext = ExprContext.ACCEPT_ALL;
            break;
        }
    e = OrderedQueryOrExpr(exprContext);
    jj_consume_token(RPAREN);
        {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

/**
 * Parses a parenthesized query or comma-list of row expressions.
 *
 * 
REVIEW jvs 8-Feb-2004: There's a small hole in this production.  It can be
 * used to construct something like
 *
 * 
 * WHERE x IN (select count(*) from t where c=d,5)
 * 
 *
 * 
which should be illegal.  The above is interpreted as equivalent to
 *
 * 
 * WHERE x IN ((select count(*) from t where c=d),5)
 * 
 *
 * 
which is a legal use of a sub-query.  The only way to fix the hole is to
 * be able to remember whether a subexpression was parenthesized or not, which
 * means preserving parentheses in the SqlNode tree.  This is probably
 * desirable anyway for use in purely syntactic parsing applications (e.g. SQL
 * pretty-printer).  However, if this is done, it's important to also make
 * isA() on the paren node call down to its operand so that we can
 * always correctly discriminate a query from a row expression.
 */
  final public SqlNodeList ParenthesizedQueryOrCommaList(ExprContext exprContext) throws ParseException {
    SqlNode e;
    List list;
    ExprContext firstExprContext = exprContext;
    final Span s;
    jj_consume_token(LPAREN);
        // we've now seen left paren, so a query by itself should
        // be interpreted as a sub-query
        s = span();
        switch (exprContext) {
        case ACCEPT_SUB_QUERY:
            firstExprContext = ExprContext.ACCEPT_NONCURSOR;
            break;
        case ACCEPT_CURSOR:
            firstExprContext = ExprContext.ACCEPT_ALL;
            break;
        }
    e = OrderedQueryOrExpr(firstExprContext);
        list = startList(e);
    label_1:
    while (true) {
      if (jj_2_18(2)) {
        ;
      } else {
        break label_1;
      }
      jj_consume_token(COMMA);
            // a comma-list can't appear where only a query is expected
            checkNonQueryExpression(exprContext);
      e = Expression(exprContext);
            list.add(e);
    }
    jj_consume_token(RPAREN);
        {if (true) return new SqlNodeList(list, s.end(this));}
    throw new Error("Missing return statement in function");
  }

/** As ParenthesizedQueryOrCommaList, but allows DEFAULT
 * in place of any of the expressions. For example,
 * {@code (x, DEFAULT, null, DEFAULT)}. */
  final public SqlNodeList ParenthesizedQueryOrCommaListWithDefault(ExprContext exprContext) throws ParseException {
    SqlNode e;
    List list;
    ExprContext firstExprContext = exprContext;
    final Span s;
    jj_consume_token(LPAREN);
        // we've now seen left paren, so a query by itself should
        // be interpreted as a sub-query
        s = span();
        switch (exprContext) {
        case ACCEPT_SUB_QUERY:
            firstExprContext = ExprContext.ACCEPT_NONCURSOR;
            break;
        case ACCEPT_CURSOR:
            firstExprContext = ExprContext.ACCEPT_ALL;
            break;
        }
    if (jj_2_19(2)) {
      e = OrderedQueryOrExpr(firstExprContext);
    } else if (jj_2_20(2)) {
      e = Default();
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
        list = startList(e);
    label_2:
    while (true) {
      if (jj_2_21(2)) {
        ;
      } else {
        break label_2;
      }
      jj_consume_token(COMMA);
            // a comma-list can't appear where only a query is expected
            checkNonQueryExpression(exprContext);
      if (jj_2_22(2)) {
        e = Expression(exprContext);
      } else if (jj_2_23(2)) {
        e = Default();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
            list.add(e);
    }
    jj_consume_token(RPAREN);
        {if (true) return new SqlNodeList(list, s.end(this));}
    throw new Error("Missing return statement in function");
  }

/**
 * Parses function parameter lists including DISTINCT keyword recognition,
 * DEFAULT, and named argument assignment.
 */
  final public List FunctionParameterList(ExprContext exprContext) throws ParseException {
    SqlNode e = null;
    List list = new ArrayList();
    jj_consume_token(LPAREN);
    if (jj_2_26(2)) {
      if (jj_2_24(2)) {
        jj_consume_token(DISTINCT);
            e = SqlSelectKeyword.DISTINCT.symbol(getPos());
      } else if (jj_2_25(2)) {
        jj_consume_token(ALL);
            e = SqlSelectKeyword.ALL.symbol(getPos());
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
    } else {
      ;
    }
        list.add(e);
    Arg0(list, exprContext);
    label_3:
    while (true) {
      if (jj_2_27(2)) {
        ;
      } else {
        break label_3;
      }
      jj_consume_token(COMMA);
            // a comma-list can't appear where only a query is expected
            checkNonQueryExpression(exprContext);
      Arg(list, exprContext);
    }
    jj_consume_token(RPAREN);
        {if (true) return list;}
    throw new Error("Missing return statement in function");
  }

  final public void Arg0(List list, ExprContext exprContext) throws ParseException {
    SqlIdentifier name = null;
    SqlNode e = null;
    final ExprContext firstExprContext;
    {
        // we've now seen left paren, so queries inside should
        // be allowed as sub-queries
        switch (exprContext) {
        case ACCEPT_SUB_QUERY:
            firstExprContext = ExprContext.ACCEPT_NONCURSOR;
            break;
        case ACCEPT_CURSOR:
            firstExprContext = ExprContext.ACCEPT_ALL;
            break;
        default:
            firstExprContext = exprContext;
            break;
        }
    }
    if (jj_2_28(2)) {
      name = SimpleIdentifier();
      jj_consume_token(NAMED_ARGUMENT_ASSIGNMENT);
    } else {
      ;
    }
    if (jj_2_29(2)) {
      e = Default();
    } else if (jj_2_30(2)) {
      e = OrderedQueryOrExpr(firstExprContext);
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
        if (e != null) {
            if (name != null) {
                e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
                    Span.of(name, e).pos(), e, name);
            }
            list.add(e);
        }
  }

  final public void Arg(List list, ExprContext exprContext) throws ParseException {
    SqlIdentifier name = null;
    SqlNode e = null;
    if (jj_2_31(2)) {
      name = SimpleIdentifier();
      jj_consume_token(NAMED_ARGUMENT_ASSIGNMENT);
    } else {
      ;
    }
    if (jj_2_32(2)) {
      e = Default();
    } else if (jj_2_33(2)) {
      e = Expression(exprContext);
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
        if (e != null) {
            if (name != null) {
                e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
                    Span.of(name, e).pos(), e, name);
            }
            list.add(e);
        }
  }

  final public SqlNode Default() throws ParseException {
    jj_consume_token(DEFAULT_);
        {if (true) return SqlStdOperatorTable.DEFAULT.createCall(getPos());}
    throw new Error("Missing return statement in function");
  }

/**
 * Parses a query (SELECT, UNION, INTERSECT, EXCEPT, VALUES, TABLE) followed by
 * the end-of-file symbol.
 */
  final public SqlNode SqlQueryEof() throws ParseException {
    SqlNode query;
    query = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY);
    jj_consume_token(0);
      {if (true) return query;}
    throw new Error("Missing return statement in function");
  }

/**
 * Parses a list of SQL statements separated by semicolon.
 * The semicolon is required between statements, but is
 * optional at the end.
 */
  final public SqlNodeList SqlStmtList() throws ParseException {
    final List stmtList = new ArrayList();
    SqlNode stmt;
    stmt = SqlStmt();
        stmtList.add(stmt);
    label_4:
    while (true) {
      if (jj_2_34(2)) {
        ;
      } else {
        break label_4;
      }
      jj_consume_token(SEMICOLON);
      if (jj_2_35(2)) {
        stmt = SqlStmt();
                stmtList.add(stmt);
      } else {
        ;
      }
    }
    jj_consume_token(0);
        {if (true) return new SqlNodeList(stmtList, Span.of(stmtList).pos());}
    throw new Error("Missing return statement in function");
  }

/**
 * Parses an SQL statement.
 */
  final public SqlNode SqlStmt() throws ParseException {
    SqlNode stmt;
    if (jj_2_36(2)) {
      stmt = SqlSetOption(Span.of(), null);
    } else if (jj_2_37(2)) {
      stmt = SqlAlter();
    } else if (jj_2_38(2)) {
      stmt = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY);
    } else if (jj_2_39(2)) {
      stmt = SqlExplain();
    } else if (jj_2_40(2)) {
      stmt = SqlDescribe();
    } else if (jj_2_41(2)) {
      stmt = SqlInsert();
    } else if (jj_2_42(2)) {
      stmt = SqlDelete();
    } else if (jj_2_43(2)) {
      stmt = SqlUpdate();
    } else if (jj_2_44(2)) {
      stmt = SqlMerge();
    } else if (jj_2_45(2)) {
      stmt = SqlProcedureCall();
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return stmt;}
    throw new Error("Missing return statement in function");
  }

/**
 * Parses an SQL statement followed by the end-of-file symbol.
 */
  final public SqlNode SqlStmtEof() throws ParseException {
    SqlNode stmt;
    stmt = SqlStmt();
    jj_consume_token(0);
        {if (true) return stmt;}
    throw new Error("Missing return statement in function");
  }

  final public JoinType LeftSemiJoin() throws ParseException {
    jj_consume_token(LEFT);
    jj_consume_token(SEMI);
    jj_consume_token(JOIN);
                           {if (true) return JoinType.LEFT_SEMI_JOIN;}
    throw new Error("Missing return statement in function");
  }

  final public SqlNode DateFunctionCall() throws ParseException {
    final SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
    final SqlIdentifier qualifiedName;
    final Span s;
    final SqlLiteral quantifier;
    final List args;
    jj_consume_token(DATE);
        s = span();
        qualifiedName = new SqlIdentifier(unquotedIdentifier(), getPos());
    args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY);
        quantifier = (SqlLiteral) args.get(0);
        args.remove(0);
        {if (true) return createCall(qualifiedName, s.end(this), funcType, quantifier, args);}
    throw new Error("Missing return statement in function");
  }

  final public SqlNode DateaddFunctionCall() throws ParseException {
    final SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
    final Span s;
    final SqlIdentifier qualifiedName;
    final TimeUnit unit;
    final List args;
    SqlNode e;
    if (jj_2_46(2)) {
      jj_consume_token(DATEADD);
    } else if (jj_2_47(2)) {
      jj_consume_token(DATEDIFF);
    } else if (jj_2_48(2)) {
      jj_consume_token(DATE_PART);
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
        s = span();
        qualifiedName = new SqlIdentifier(unquotedIdentifier(), getPos());
    jj_consume_token(LPAREN);
    unit = TimeUnit();
        args = startList(new SqlIntervalQualifier(unit, null, getPos()));
    label_5:
    while (true) {
      if (jj_2_49(2)) {
        ;
      } else {
        break label_5;
      }
      jj_consume_token(COMMA);
      e = Expression(ExprContext.ACCEPT_SUB_QUERY);
            args.add(e);
    }
    jj_consume_token(RPAREN);
        {if (true) return createCall(qualifiedName, s.end(this), funcType, null, args);}
    throw new Error("Missing return statement in function");
  }

/** Parses the infix "::" cast operator used in PostgreSQL. */
  final public void InfixCast(List