org.apache.storm.sql.parser.impl

## Class StormParserImpl

- java.lang.Object
- - org.apache.calcite.sql.parser.SqlAbstractParserImpl
  - - org.apache.storm.sql.parser.impl.StormParserImpl

- All Implemented Interfaces:
    StormParserImplConstants

      public class StormParserImpl
      extends org.apache.calcite.sql.parser.SqlAbstractParserImpl
      implements StormParserImplConstants

  SQL parser, generated from Parser.jj by JavaCC.

  The public wrapper for this parser is `SqlParser`.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.apache.calcite.sql.parser.SqlAbstractParserImpl

      `org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext, org.apache.calcite.sql.parser.SqlAbstractParserImpl.Metadata, org.apache.calcite.sql.parser.SqlAbstractParserImpl.MetadataImpl`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static org.apache.calcite.sql.parser.SqlParserImplFactory` | `FACTORY` `SqlParserImplFactory` implementation for creating parser.
    `Token` | `jj_nt`
    `boolean` | `lookingAhead`
    `Token` | `token`
    `StormParserImplTokenManager` | `token_source`

    - ### Fields inherited from class org.apache.calcite.sql.parser.SqlAbstractParserImpl

      `nDynamicParams, opTab, originalSql`

    - ### Fields inherited from interface org.apache.storm.sql.parser.impl.StormParserImplConstants

      `A, ABS, ABSOLUTE, ACTION, ADA, ADD, ADMIN, AFTER, ALL, ALLOCATE, ALLOW, ALTER, ALWAYS, AND, ANY, APPLY, APPROX_NUMERIC_LITERAL, ARE, ARRAY, ARRAY_MAX_CARDINALITY, AS, ASC, ASENSITIVE, ASSERTION, ASSIGNMENT, ASYMMETRIC, AT, ATOMIC, ATTRIBUTE, ATTRIBUTES, AUTHORIZATION, AVG, BACK_QUOTED_IDENTIFIER, BEFORE, BEGIN, BEGIN_FRAME, BEGIN_PARTITION, BEL, BERNOULLI, BETWEEN, BIGINT, BINARY, BINARY_STRING_LITERAL, BIT, BLOB, BOOLEAN, BOTH, BRACKET_QUOTED_IDENTIFIER, BREADTH, BTID, BY, C, CALL, CALLED, CARDINALITY, CARET, CASCADE, CASCADED, CASE, CAST, CATALOG, CATALOG_NAME, CEIL, CEILING, CENTURY, CHAIN, CHAR, CHAR_LENGTH, CHARACTER, CHARACTER_LENGTH, CHARACTER_SET_CATALOG, CHARACTER_SET_NAME, CHARACTER_SET_SCHEMA, CHARACTERISTICS, CHARACTERS, CHARSETNAME, CHECK, CLASS_ORIGIN, CLASSIFIER, CLOB, CLOSE, COALESCE, COBOL, COLLATE, COLLATION, COLLATION_CATALOG, COLLATION_ID, COLLATION_NAME, COLLATION_SCHEMA, COLLECT, COLON, COLUMN, COLUMN_NAME, COMMA, COMMAND_FUNCTION, COMMAND_FUNCTION_CODE, COMMIT, COMMITTED, CONCAT, CONDITION, CONDITION_NUMBER, CONNECT, CONNECTION, CONNECTION_NAME, CONSTRAINT, CONSTRAINT_CATALOG, CONSTRAINT_NAME, CONSTRAINT_SCHEMA, CONSTRAINTS, CONSTRUCTOR, CONTAINS, CONTINUE, CONVERT, CORR, CORRESPONDING, COUNT, COVAR_POP, COVAR_SAMP, CREATE, CROSS, CUBE, CUME_DIST, CURRENT, CURRENT_CATALOG, CURRENT_DATE, CURRENT_DEFAULT_TRANSFORM_GROUP, CURRENT_PATH, CURRENT_ROLE, CURRENT_ROW, CURRENT_SCHEMA, CURRENT_TIME, CURRENT_TIMESTAMP, CURRENT_TRANSFORM_GROUP_FOR_TYPE, CURRENT_USER, CURSOR, CURSOR_NAME, CYCLE, DATA, DATABASE, DATE, DATETIME_INTERVAL_CODE, DATETIME_INTERVAL_PRECISION, DAY, DEALLOCATE, DEC, DECADE, DECIMAL, DECIMAL_NUMERIC_LITERAL, DECLARE, DEFAULT, DEFAULT_, DEFAULTS, DEFERRABLE, DEFERRED, DEFINE, DEFINED, DEFINER, DEGREE, DELETE, DENSE_RANK, DEPTH, DEREF, DERIVED, DESC, DESCRIBE, DESCRIPTION, DESCRIPTOR, DETERMINISTIC, DIAGNOSTICS, DIGIT, DISALLOW, DISCONNECT, DISPATCH, DISTINCT, DOLLAR, DOMAIN, DOT, DOUBLE, DOUBLE_PERIOD, DOW, DOY, DQID, DROP, DYNAMIC, DYNAMIC_FUNCTION, DYNAMIC_FUNCTION_CODE, EACH, ELEMENT, ELSE, EMPTY, END, END_EXEC, END_FRAME, END_PARTITION, EOF, EPOCH, EQ, EQUALS, ESCAPE, EVERY, EXCEPT, EXCEPTION, EXCLUDE, EXCLUDING, EXEC, EXECUTE, EXISTS, EXP, EXPLAIN, EXPONENT, EXTEND, EXTERNAL, EXTRACT, FALSE, FETCH, FILTER, FINAL, FIRST, FIRST_VALUE, FLOAT, FLOOR, FOLLOWING, FOR, FOREIGN, FORMAL_COMMENT, FORTRAN, FOUND, FRAC_SECOND, FRAME_ROW, FREE, FROM, FULL, FUNCTION, FUSION, G, GE, GENERAL, GENERATED, GEOMETRY, GET, GLOBAL, GO, GOTO, GRANT, GRANTED, GROUP, GROUPING, GROUPS, GT, HAVING, HEXDIGIT, HIERARCHY, HOLD, HOOK, HOUR, IDENTIFIER, IDENTITY, IMMEDIATE, IMMEDIATELY, IMPLEMENTATION, IMPORT, IN, IN_FORMAL_COMMENT, IN_MULTI_LINE_COMMENT, INCLUDING, INCREMENT, INDICATOR, INITIAL, INITIALLY, INNER, INOUT, INPUT, INPUTFORMAT, INSENSITIVE, INSERT, INSTANCE, INSTANTIABLE, INT, INTEGER, INTERSECT, INTERSECTION, INTERVAL, INTO, INVOKER, IS, ISOLATION, JAR, JAVA, JOIN, JSON, K, KEY, KEY_MEMBER, KEY_TYPE, LABEL, LAG, LANGUAGE, LARGE, LAST, LAST_VALUE, LATERAL, LBRACE, LBRACE_D, LBRACE_FN, LBRACE_T, LBRACE_TS, LBRACKET, LE, LEAD, LEADING, LEFT, LENGTH, LETTER, LEVEL, LIBRARY, LIKE, LIKE_REGEX, LIMIT, LN, LOCAL, LOCALTIME, LOCALTIMESTAMP, LOCATION, LOCATOR, LOWER, LPAREN, LT, M, MAP, MATCH, MATCH_NUMBER, MATCH_RECOGNIZE, MATCHED, MATCHES, MAX, MAXVALUE, MEASURES, MEMBER, MERGE, MESSAGE_LENGTH, MESSAGE_OCTET_LENGTH, MESSAGE_TEXT, METHOD, MICROSECOND, MILLENNIUM, MIN, MINUS, MINUTE, MINVALUE, MOD, MODIFIES, MODULE, MONTH, MORE_, MULTI_LINE_COMMENT, MULTISET, MUMPS, NAME, NAMED_ARGUMENT_ASSIGNMENT, NAMES, NATIONAL, NATURAL, NCHAR, NCLOB, NE, NE2, NESTING, NEW, NEXT, NO, NONE, NORMALIZE, NORMALIZED, NOT, NTH_VALUE, NTILE, NULL, NULLABLE, NULLIF, NULLS, NUMBER, NUMERIC, OBJECT, OCCURRENCES_REGEX, OCTET_LENGTH, OCTETS, OF, OFFSET, OLD, OMIT, ON, ONE, ONLY, OPEN, OPTION, OPTIONS, OR, ORDER, ORDERING, ORDINALITY, OTHERS, OUT, OUTER, OUTPUT, OUTPUTFORMAT, OVER, OVERLAPS, OVERLAY, OVERRIDING, PAD, PARALLELISM, PARAMETER, PARAMETER_MODE, PARAMETER_NAME, PARAMETER_ORDINAL_POSITION, PARAMETER_SPECIFIC_CATALOG, PARAMETER_SPECIFIC_NAME, PARAMETER_SPECIFIC_SCHEMA, PARTIAL, PARTITION, PASCAL, PASSTHROUGH, PAST, PATH, PATTERN, PER, PERCENT, PERCENT_RANK, PERCENT_REMAINDER, PERCENTILE_CONT, PERCENTILE_DISC, PERIOD, PERMUTE, PLACING, PLAN, PLI, PLUS, PORTION, POSITION, POSITION_REGEX, POWER, PRECEDES, PRECEDING, PRECISION, PREFIXED_STRING_LITERAL, PREPARE, PRESERVE, PREV, PRIMARY, PRIOR, PRIVILEGES, PROCEDURE, PUBLIC, QUARTER, QUOTE, QUOTED_IDENTIFIER, QUOTED_STRING, RANGE, RANK, RBRACE, RBRACKET, READ, READS, REAL, RECURSIVE, REF, REFERENCES, REFERENCING, REGR_AVGX, REGR_AVGY, REGR_COUNT, REGR_INTERCEPT, REGR_R2, REGR_SLOPE, REGR_SXX, REGR_SXY, REGR_SYY, RELATIVE, RELEASE, REPEATABLE, REPLACE, RESET, RESTART, RESTRICT, RESULT, RETURN, RETURNED_CARDINALITY, RETURNED_LENGTH, RETURNED_OCTET_LENGTH, RETURNED_SQLSTATE, RETURNS, REVOKE, RIGHT, ROLE, ROLLBACK, ROLLUP, ROUTINE, ROUTINE_CATALOG, ROUTINE_NAME, ROUTINE_SCHEMA, ROW, ROW_COUNT, ROW_NUMBER, ROWS, RPAREN, RUNNING, SAVEPOINT, SCALE, SCHEMA, SCHEMA_NAME, SCOPE, SCOPE_CATALOGS, SCOPE_NAME, SCOPE_SCHEMA, SCROLL, SEARCH, SECOND, SECTION, SECURITY, SEEK, SELECT, SELF, SEMICOLON, SENSITIVE, SEQUENCE, SERIALIZABLE, SERVER, SERVER_NAME, SESSION, SESSION_USER, SET, SET_MINUS, SETS, SHOW, SIMILAR, SIMPLE, SINGLE_LINE_COMMENT, SIZE, SKIP_, SLASH, SMALLINT, SOME, SOURCE, SPACE, SPECIFIC, SPECIFIC_NAME, SPECIFICTYPE, SQL, SQL_BIGINT, SQL_BINARY, SQL_BIT, SQL_BLOB, SQL_BOOLEAN, SQL_CHAR, SQL_CLOB, SQL_DATE, SQL_DECIMAL, SQL_DOUBLE, SQL_FLOAT, SQL_INTEGER, SQL_INTERVAL_DAY, SQL_INTERVAL_DAY_TO_HOUR, SQL_INTERVAL_DAY_TO_MINUTE, SQL_INTERVAL_DAY_TO_SECOND, SQL_INTERVAL_HOUR, SQL_INTERVAL_HOUR_TO_MINUTE, SQL_INTERVAL_HOUR_TO_SECOND, SQL_INTERVAL_MINUTE, SQL_INTERVAL_MINUTE_TO_SECOND, SQL_INTERVAL_MONTH, SQL_INTERVAL_SECOND, SQL_INTERVAL_YEAR, SQL_INTERVAL_YEAR_TO_MONTH, SQL_LONGVARBINARY, SQL_LONGVARCHAR, SQL_LONGVARNCHAR, SQL_NCHAR, SQL_NCLOB, SQL_NUMERIC, SQL_NVARCHAR, SQL_REAL, SQL_SMALLINT, SQL_TIME, SQL_TIMESTAMP, SQL_TINYINT, SQL_TSI_DAY, SQL_TSI_FRAC_SECOND, SQL_TSI_HOUR, SQL_TSI_MICROSECOND, SQL_TSI_MINUTE, SQL_TSI_MONTH, SQL_TSI_QUARTER, SQL_TSI_SECOND, SQL_TSI_WEEK, SQL_TSI_YEAR, SQL_VARBINARY, SQL_VARCHAR, SQLEXCEPTION, SQLSTATE, SQLWARNING, SQRT, STAR, START, STATE, STATEMENT, STATIC, STDDEV_POP, STDDEV_SAMP, STORED, STREAM, STRUCTURE, STYLE, SUBCLASS_ORIGIN, SUBMULTISET, SUBSET, SUBSTITUTE, SUBSTRING, SUBSTRING_REGEX, SUCCEEDS, SUM, SYMMETRIC, SYSTEM, SYSTEM_TIME, SYSTEM_USER, TABLE, TABLE_NAME, TABLESAMPLE, TBLPROPERTIES, TEMPORARY, THEN, TIES, TIME, TIMESTAMP, TIMESTAMPADD, TIMESTAMPDIFF, TIMEZONE_HOUR, TIMEZONE_MINUTE, TINYINT, TO, tokenImage, TOP_LEVEL_COUNT, TRAILING, TRANSACTION, TRANSACTIONS_ACTIVE, TRANSACTIONS_COMMITTED, TRANSACTIONS_ROLLED_BACK, TRANSFORM, TRANSFORMS, TRANSLATE, TRANSLATE_REGEX, TRANSLATION, TREAT, TRIGGER, TRIGGER_CATALOG, TRIGGER_NAME, TRIGGER_SCHEMA, TRIM, TRIM_ARRAY, TRUE, TRUNCATE, TYPE, UESCAPE, UNBOUNDED, UNCOMMITTED, UNDER, UNICODE_QUOTED_ESCAPE_CHAR, UNICODE_QUOTED_IDENTIFIER, UNICODE_STRING_LITERAL, UNION, UNIQUE, UNKNOWN, UNNAMED, UNNEST, UNSIGNED_INTEGER_LITERAL, UPDATE, UPPER, UPSERT, USAGE, USER, USER_DEFINED_TYPE_CATALOG, USER_DEFINED_TYPE_CODE, USER_DEFINED_TYPE_NAME, USER_DEFINED_TYPE_SCHEMA, USING, VALUE, VALUE_OF, VALUES, VAR_POP, VAR_SAMP, VARBINARY, VARCHAR, VARYING, VERSION, VERSIONING, VERTICAL_BAR, VIEW, WEEK, WHEN, WHENEVER, WHERE, WHITESPACE, WIDTH_BUCKET, WINDOW, WITH, WITHIN, WITHOUT, WORK, WRAPPER, WRITE, XML, YEAR, ZONE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `StormParserImpl(InputStream stream)`
    `StormParserImpl(InputStream stream, String encoding)`
    `StormParserImpl(Reader stream)`
    `StormParserImpl(StormParserImplTokenManager tm)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `Arg(List list, org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)`
    `void` | `Arg0(List list, org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)`
    `org.apache.calcite.sql.SqlNode` | `ArrayConstructor()` Parses an ARRAY constructor
    `org.apache.calcite.sql.SqlNode` | `AtomicRowExpression()` Parses an atomic row expression.
    `org.apache.calcite.sql.SqlBinaryOperator` | `BinaryMultisetOperator()` Parses a binary multiset operator.
    `org.apache.calcite.sql.SqlBinaryOperator` | `BinaryQueryOperator()` Parses a binary query operator like UNION.
    `org.apache.calcite.sql.SqlBinaryOperator` | `BinaryRowOperator()` Parses a binary row operator like AND.
    `org.apache.calcite.sql.SqlNode` | `BuiltinFunctionCall()` Parses a call to a builtin function with special syntax.
    `org.apache.calcite.sql.SqlNode` | `CaseExpression()`
    `org.apache.calcite.sql.SqlCollation` | `CollateClause()` Parses a COLLATE clause
    `org.apache.calcite.sql.SqlIdentifier` | `CollectionsTypeName()`
    `org.apache.calcite.sql.SqlNodeList` | `ColumnDefinitionList()`
    `void` | `ColumnType(List<org.apache.calcite.sql.SqlNode> list)`
    `String` | `CommonNonReservedKeyWord()` Parses a non-reserved keyword for use as an identifier.
    `org.apache.calcite.sql.SqlKind` | `comp()` Parses a comparison operator inside a SOME / ALL predicate.
    `org.apache.calcite.sql.SqlIdentifier` | `CompoundIdentifier()` Parses a compound identifier.
    `void` | `CompoundIdentifierType(List<org.apache.calcite.sql.SqlNode> list, List<org.apache.calcite.sql.SqlNode> extendList)` Parses a compound identifier with optional type.
    `void` | `CompoundIdentifierTypeCommaList(List<org.apache.calcite.sql.SqlNode> list, List<org.apache.calcite.sql.SqlNode> extendList)` Parses a comma-separated list of compound identifiers.
    `org.apache.calcite.sql.SqlIdentifier` | `ContextVariable()`
    `org.apache.calcite.sql.SqlNode` | `CursorExpression(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a CURSOR(query) expression.
    `org.apache.calcite.sql.SqlDataTypeSpec` | `DataType()`
    `org.apache.calcite.sql.SqlLiteral` | `DateTimeLiteral()` Parses a date/time literal.
    `void` | `disable_tracing()`
    `org.apache.calcite.sql.SqlDynamicParam` | `DynamicParam()` Parses a dynamic parameter marker.
    `void` | `enable_tracing()`
    `org.apache.calcite.sql.SqlExplain.Depth` | `ExplainDepth()` Parses WITH TYPE | WITH IMPLEMENTATION | WITHOUT IMPLEMENTATION modifier for EXPLAIN PLAN.
    `org.apache.calcite.sql.SqlExplainLevel` | `ExplainDetailLevel()` Parses INCLUDING ALL ATTRIBUTES modifier for EXPLAIN PLAN.
    `org.apache.calcite.sql.SqlNode` | `ExplicitTable(org.apache.calcite.sql.parser.SqlParserPos pos)` Parses an explicit TABLE t reference.
    `org.apache.calcite.sql.SqlNode` | `Expression(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a row expression or a parenthesized expression of any kind.
    `List<Object>` | `Expression2(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a binary row expression, or a parenthesized expression of any kind.
    `void` | `Expression2b(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext, List<Object> list)`
    `org.apache.calcite.sql.SqlNode` | `Expression3(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a unary row expression, or a parenthesized expression of any kind.
    `org.apache.calcite.sql.SqlNodeList` | `ExpressionCommaList(org.apache.calcite.sql.parser.Span s, org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a list of expressions separated by commas.
    `org.apache.calcite.sql.SqlNode` | `ExtendedBuiltinFunctionCall()`
    `org.apache.calcite.sql.SqlNode` | `ExtendedTableRef()` Allows parser to be extended with new types of table references.
    `org.apache.calcite.sql.SqlNodeList` | `ExtendList()`
    `org.apache.calcite.sql.SqlNode` | `FloorCeilOptions(org.apache.calcite.sql.parser.Span s, boolean floorFlag)`
    `org.apache.calcite.sql.SqlNode` | `FromClause()` Parses the FROM clause for a SELECT.
    `org.apache.calcite.sql.SqlIdentifier` | `FunctionName()` Parses the name of a function (either a compound identifier or a reserved word which can be used as a function name).
    `List` | `FunctionParameterList(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses function parameter lists including DISTINCT keyword recognition, DEFAULT, and named argument assignment.
    `ParseException` | `generateParseException()`
    `org.apache.calcite.sql.parser.SqlAbstractParserImpl.Metadata` | `getMetadata()`
    `Token` | `getNextToken()`
    `protected org.apache.calcite.sql.parser.SqlParserPos` | `getPos()`
    `Token` | `getToken(int index)`
    `org.apache.calcite.sql.SqlNodeList` | `GroupByOpt()` Parses the optional GROUP BY clause for SELECT.
    `org.apache.calcite.sql.SqlNode` | `GroupingElement()`
    `List<org.apache.calcite.sql.SqlNode>` | `GroupingElementList()`
    `org.apache.calcite.sql.SqlNode` | `HavingOpt()` Parses the optional HAVING clause for SELECT.
    `String` | `Identifier()` Parses a simple identifier as a string.
    `org.apache.calcite.sql.SqlLiteral` | `IntervalLiteral()` Parses an interval literal.
    `org.apache.calcite.sql.SqlIntervalQualifier` | `IntervalQualifier()`
    `int` | `IntLiteral()`
    `org.apache.calcite.sql.SqlNode` | `JdbcFunctionCall()` Parses a function call expression with JDBC syntax.
    `org.apache.calcite.sql.SqlLiteral` | `JdbcOdbcDataType()`
    `org.apache.calcite.sql.SqlJdbcDataTypeName` | `JdbcOdbcDataTypeName()`
    `org.apache.calcite.sql.SqlNode` | `JoinTable(org.apache.calcite.sql.SqlNode e)` Matches “LEFT JOIN t ON …”, “RIGHT JOIN t USING …”, “JOIN t”.
    `org.apache.calcite.sql.SqlLiteral` | `JoinType()`
    `org.apache.calcite.sql.SqlNode` | `LeafQuery(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a leaf in a query expression (SELECT, VALUES or TABLE).
    `org.apache.calcite.sql.SqlNode` | `LeafQueryOrExpr(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses either a row expression, a leaf query expression, or a parenthesized expression of any kind.
    `org.apache.calcite.sql.SqlNode` | `Literal()` Parses a literal expression, allowing continued string literals.
    `org.apache.calcite.sql.SqlNode` | `MapConstructor()` Parses a MAP constructor
    `org.apache.calcite.sql.SqlCall` | `MatchRecognizeCallWithModifier()`
    `org.apache.calcite.sql.SqlCall` | `MatchRecognizeFunctionCall()`
    `org.apache.calcite.sql.SqlCall` | `MatchRecognizeNavigationLogical()`
    `org.apache.calcite.sql.SqlCall` | `MatchRecognizeNavigationPhysical()`
    `org.apache.calcite.sql.SqlMatchRecognize` | `MatchRecognizeOpt(org.apache.calcite.sql.SqlNode tableRef)` Parses a MATCH_RECOGNIZE clause following a table expression.
    `org.apache.calcite.sql.SqlNode` | `MeasureColumn()`
    `org.apache.calcite.sql.SqlNodeList` | `MeasureColumnCommaList(org.apache.calcite.sql.parser.Span s)`
    `org.apache.calcite.sql.SqlNode` | `MultisetConstructor()` Parses a MULTISET constructor
    `org.apache.calcite.sql.SqlNode` | `NamedFunctionCall()` Parses a call to a named function (could be a builtin with regular syntax, or else a UDF).
    `org.apache.calcite.sql.SqlNode` | `NamedRoutineCall(org.apache.calcite.sql.SqlFunctionCategory routineType, org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)`
    `org.apache.calcite.sql.SqlLiteral` | `Natural()`
    `org.apache.calcite.sql.SqlNode` | `NewSpecification()` Parses a NEW UDT(…) expression.
    `String` | `NonReservedJdbcFunctionName()` Parses the name of a JDBC function that is a token but is not reserved.
    `String` | `NonReservedKeyWord()`
    `org.apache.calcite.sql.parser.SqlParseException` | `normalizeException(Throwable ex)`
    `org.apache.calcite.sql.SqlLiteral` | `NumericLiteral()` Parses a numeric literal (can be signed)
    `org.apache.calcite.sql.SqlNodeList` | `OrderBy(boolean accept)` Parses an ORDER BY clause.
    `org.apache.calcite.sql.SqlNode` | `OrderedQueryOrExpr(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses either a row expression or a query expression with an optional ORDER BY.
    `org.apache.calcite.sql.SqlNode` | `OrderItem()` Parses one list item in an ORDER BY clause.
    `org.apache.calcite.util.Pair<org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNodeList>` | `ParenthesizedCompoundIdentifierList()` List of compound identifiers in parentheses.
    `org.apache.calcite.sql.SqlNode` | `ParenthesizedExpression(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a parenthesized query or single row expression.
    `org.apache.calcite.sql.SqlNodeList` | `ParenthesizedQueryOrCommaList(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses a parenthesized query or comma-list of row expressions.
    `org.apache.calcite.sql.SqlNodeList` | `ParenthesizedSimpleIdentifierList()` List of simple identifiers in parentheses.
    `org.apache.calcite.sql.SqlNode` | `parseSqlExpressionEof()`
    `org.apache.calcite.sql.SqlNode` | `parseSqlStmtEof()`
    `org.apache.calcite.sql.SqlNode` | `PatternDefinition()`
    `org.apache.calcite.sql.SqlNodeList` | `PatternDefinitionCommaList(org.apache.calcite.sql.parser.Span s)`
    `org.apache.calcite.sql.SqlNode` | `PatternExpression()`
    `org.apache.calcite.sql.SqlNode` | `PatternFactor()`
    `org.apache.calcite.sql.SqlNode` | `PatternPrimary()`
    `org.apache.calcite.sql.SqlNode` | `PatternTerm()`
    `org.apache.calcite.sql.SqlNode` | `PeriodConstructor()` Parses a PERIOD constructor
    `org.apache.calcite.sql.SqlOperator` | `periodOperator()`
    `org.apache.calcite.sql.SqlPostfixOperator` | `PostfixRowOperator()` Parses a postfix row operator like IS NOT NULL.
    `org.apache.calcite.sql.SqlPrefixOperator` | `PrefixRowOperator()` Parses a prefix row operator like NOT.
    `org.apache.calcite.sql.SqlNode` | `QueryOrExpr(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)` Parses either a row expression or a query expression without ORDER BY.
    `void` | `ReInit(InputStream stream)`
    `void` | `ReInit(InputStream stream, String encoding)`
    `void` | `ReInit(Reader stream)`
    `void` | `ReInit(StormParserImplTokenManager tm)`
    `org.apache.calcite.sql.SqlIdentifier` | `ReservedFunctionName()` Parses a reserved word which is used as the name of a function.
    `org.apache.calcite.sql.SqlNode` | `RowConstructor()` Parses a row constructor in the context of a VALUES expression.
    `org.apache.calcite.sql.SqlNodeList` | `RowConstructorList(org.apache.calcite.sql.parser.Span s)` Parses one or more rows in a VALUES expression.
    `String` | `Scope()`
    `org.apache.calcite.sql.SqlNode` | `SelectExpression()` Parses one unaliased expression in a select list.
    `org.apache.calcite.sql.SqlNode` | `SelectItem()` Parses one item in a select list.
    `List<org.apache.calcite.sql.SqlNode>` | `SelectList()` Parses the select list of a SELECT statement.
    `org.apache.calcite.sql.SqlCall` | `SequenceExpression()`
    `void` | `setConformance(org.apache.calcite.sql.validate.SqlConformance conformance)`
    `void` | `setIdentifierMaxLength(int identifierMaxLength)`
    `void` | `setQuotedCasing(org.apache.calcite.avatica.util.Casing quotedCasing)`
    `void` | `setTabSize(int tabSize)`
    `void` | `setUnquotedCasing(org.apache.calcite.avatica.util.Casing unquotedCasing)`
    `org.apache.calcite.sql.SqlIdentifier` | `SimpleIdentifier()` Parses a simple identifier as an SqlIdentifier.
    `void` | `SimpleIdentifierCommaList(List<org.apache.calcite.sql.SqlNode> list)` Parses a comma-separated list of simple identifiers.
    `org.apache.calcite.sql.SqlLiteral` | `SpecialLiteral()` Parse a special literal keyword
    `org.apache.calcite.sql.SqlAlter` | `SqlAlter()` Parses an expression for setting or resetting an option in SQL, such as QUOTED_IDENTIFIERS, or explain plan level (physical/logical).
    `org.apache.calcite.sql.SqlNode` | `SqlCreateFunction()` CREATE FUNCTION functionname AS ‘classname’
    `org.apache.calcite.sql.SqlNode` | `SqlCreateTable()` CREATE EXTERNAL TABLE ( IF NOT EXISTS )? ( database_name ‘.’ )? table_name ( ‘(’ column_def ( ‘,’ column_def )* ‘)’ ( STORED AS INPUTFORMAT input_format_classname OUTPUTFORMAT output_format_classname )? LOCATION location_uri ( TBLPROPERTIES tbl_properties )? ( AS select_stmt )
    `org.apache.calcite.sql.SqlNode` | `SqlDelete()` Parses a DELETE statement.
    `org.apache.calcite.sql.SqlNode` | `SqlDescribe()` Parses a DESCRIBE statement.
    `org.apache.calcite.sql.SqlNode` | `SqlExplain()` Parses an EXPLAIN PLAN statement.
    `org.apache.calcite.sql.SqlNode` | `SqlExpressionEof()` Parses a SQL expression (such as might occur in a WHERE clause) followed by the end-of-file symbol.
    `org.apache.calcite.sql.SqlNode` | `SqlInsert()` Parses an INSERT statement.
    `void` | `SqlInsertKeywords(List<org.apache.calcite.sql.SqlLiteral> keywords)`
    `org.apache.calcite.sql.SqlNode` | `SqlMerge()` Parses a MERGE statement.
    `org.apache.calcite.sql.SqlNode` | `SqlProcedureCall()` Parses a CALL statement.
    `org.apache.calcite.sql.SqlNode` | `SqlQueryEof()` Parses a query (SELECT, UNION, INTERSECT, EXCEPT, VALUES, TABLE) followed by the end-of-file symbol.
    `org.apache.calcite.sql.SqlNode` | `SqlQueryOrDml()` Parses a query (SELECT or VALUES) or DML statement (INSERT, UPDATE, DELETE, MERGE).
    `org.apache.calcite.sql.SqlSelect` | `SqlSelect()` Parses a leaf SELECT expression without ORDER BY.
    `void` | `SqlSelectKeywords(List<org.apache.calcite.sql.SqlLiteral> keywords)`
    `org.apache.calcite.sql.SqlSetOption` | `SqlSetOption(org.apache.calcite.sql.parser.Span s, String scope)` Parses “SET <NAME> = VALUE” or “RESET <NAME>”, without a leading “ALTER <SCOPE>”.
    `org.apache.calcite.sql.SqlNode` | `SqlStmt()` Parses an SQL statement.
    `org.apache.calcite.sql.SqlNode` | `SqlStmtEof()` Parses an SQL statement followed by the end-of-file symbol.
    `org.apache.calcite.sql.type.SqlTypeName` | `SqlTypeName(org.apache.calcite.sql.parser.Span s)`
    `org.apache.calcite.sql.SqlNode` | `SqlUpdate()` Parses an UPDATE statement.
    `org.apache.calcite.sql.SqlNode` | `StandardFloorCeilOptions(org.apache.calcite.sql.parser.Span s, boolean floorFlag)`
    `org.apache.calcite.sql.SqlNode` | `StringLiteral()` Parses a string literal.
    `org.apache.calcite.sql.SqlNode` | `SubsetDefinition()`
    `org.apache.calcite.sql.SqlNodeList` | `SubsetDefinitionCommaList(org.apache.calcite.sql.parser.Span s)`
    `void` | `switchTo(String stateName)`
    `org.apache.calcite.sql.SqlNode` | `TableConstructor()` Parses a VALUES leaf query expression.
    `org.apache.calcite.sql.SqlNode` | `TableFunctionCall(org.apache.calcite.sql.parser.SqlParserPos pos)`
    `org.apache.calcite.sql.SqlNode` | `TableOverOpt()` Allows an OVER clause following a table expression as an extension to standard SQL syntax.
    `org.apache.calcite.sql.SqlNode` | `TableRef()` Parses a table reference in a FROM clause, not lateral unless LATERAL is explicitly specified.
    `org.apache.calcite.sql.SqlNode` | `TableRef2(boolean lateral)` Parses a table reference in a FROM clause.
    `org.apache.calcite.sql.SqlCall` | `TimestampAddFunctionCall()` Parses a call to TIMESTAMPADD.
    `org.apache.calcite.sql.SqlCall` | `TimestampDiffFunctionCall()` Parses a call to TIMESTAMPDIFF.
    `org.apache.calcite.avatica.util.TimeUnit` | `TimestampInterval()`
    `org.apache.calcite.avatica.util.TimeUnit` | `TimeUnit()` Parses time unit for EXTRACT, CEIL and FLOOR functions.
    `org.apache.calcite.sql.SqlIdentifier` | `TypeName()`
    `int` | `UnsignedIntLiteral()`
    `org.apache.calcite.sql.SqlNumericLiteral` | `UnsignedNumericLiteral()` Parses a unsigned numeric literal
    `void` | `UnusedExtension()` Defines a production which can never be accepted by the parser.
    `org.apache.calcite.sql.SqlUpdate` | `WhenMatchedClause(org.apache.calcite.sql.SqlNode table, org.apache.calcite.sql.SqlIdentifier alias)`
    `org.apache.calcite.sql.SqlInsert` | `WhenNotMatchedClause(org.apache.calcite.sql.SqlNode table)`
    `org.apache.calcite.sql.SqlNode` | `WhereOpt()` Parses the optional WHERE clause for SELECT, DELETE, and UPDATE.
    `org.apache.calcite.sql.SqlNodeList` | `WindowOpt()` Parses the optional WINDOW clause for SELECT
    `org.apache.calcite.sql.SqlNode` | `WindowRange()`
    `org.apache.calcite.sql.SqlWindow` | `WindowSpecification()` Parses a window specification.
    `org.apache.calcite.sql.SqlWithItem` | `WithItem()`
    `org.apache.calcite.sql.SqlNodeList` | `WithList()`

    - ### Methods inherited from class org.apache.calcite.sql.parser.SqlAbstractParserImpl

      `createCall, createCall, getOriginalSql, getSql92ReservedWords, setOriginalSql`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### FACTORY

          public static final org.apache.calcite.sql.parser.SqlParserImplFactory FACTORY

      `SqlParserImplFactory` implementation for creating parser.

    - #### token_source

          public StormParserImplTokenManager token_source

    - #### token

          public Token token

    - #### jj_nt

          public Token jj_nt

    - #### lookingAhead

          public boolean lookingAhead

  - ### Constructor Detail

    - #### StormParserImpl

          public StormParserImpl(InputStream stream)

    - #### StormParserImpl

          public StormParserImpl(InputStream stream,
                                 String encoding)

    - #### StormParserImpl

          public StormParserImpl(Reader stream)

    - #### StormParserImpl

          public StormParserImpl(StormParserImplTokenManager tm)

  - ### Method Detail

    - #### normalizeException

          public org.apache.calcite.sql.parser.SqlParseException normalizeException(Throwable ex)

      Specified by:
        `normalizeException` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### getMetadata

          public org.apache.calcite.sql.parser.SqlAbstractParserImpl.Metadata getMetadata()

      Specified by:
        `getMetadata` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### setTabSize

          public void setTabSize(int tabSize)

      Specified by:
        `setTabSize` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### switchTo

          public void switchTo(String stateName)

      Specified by:
        `switchTo` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### setQuotedCasing

          public void setQuotedCasing(org.apache.calcite.avatica.util.Casing quotedCasing)

      Specified by:
        `setQuotedCasing` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### setUnquotedCasing

          public void setUnquotedCasing(org.apache.calcite.avatica.util.Casing unquotedCasing)

      Specified by:
        `setUnquotedCasing` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### setIdentifierMaxLength

          public void setIdentifierMaxLength(int identifierMaxLength)

      Specified by:
        `setIdentifierMaxLength` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### setConformance

          public void setConformance(org.apache.calcite.sql.validate.SqlConformance conformance)

      Specified by:
        `setConformance` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### parseSqlExpressionEof

          public org.apache.calcite.sql.SqlNode parseSqlExpressionEof()
                                                               throws Exception

      Specified by:
        `parseSqlExpressionEof` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`
      Throws:
        `Exception`

    - #### parseSqlStmtEof

          public org.apache.calcite.sql.SqlNode parseSqlStmtEof()
                                                         throws Exception

      Specified by:
        `parseSqlStmtEof` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`
      Throws:
        `Exception`

    - #### NonReservedKeyWord

          public final String NonReservedKeyWord()
                                          throws ParseException

      Throws:
        `ParseException`

    - #### ExtendedTableRef

          public final org.apache.calcite.sql.SqlNode ExtendedTableRef()
                                                                throws ParseException

      Allows parser to be extended with new types of table references. The default implementation of this production is empty.

      Throws:
        `ParseException`

    - #### TableOverOpt

          public final org.apache.calcite.sql.SqlNode TableOverOpt()
                                                            throws ParseException

      Allows an OVER clause following a table expression as an extension to standard SQL syntax. The default implementation of this production is empty.

      Throws:
        `ParseException`

    - #### SqlSelectKeywords

          public final void SqlSelectKeywords(List<org.apache.calcite.sql.SqlLiteral> keywords)
                                       throws ParseException

      Throws:
        `ParseException`

    - #### SqlInsertKeywords

          public final void SqlInsertKeywords(List<org.apache.calcite.sql.SqlLiteral> keywords)
                                       throws ParseException

      Throws:
        `ParseException`

    - #### ExtendedBuiltinFunctionCall

          public final org.apache.calcite.sql.SqlNode ExtendedBuiltinFunctionCall()
                                                                           throws ParseException

      Throws:
        `ParseException`

    - #### FloorCeilOptions

          public final org.apache.calcite.sql.SqlNode FloorCeilOptions(org.apache.calcite.sql.parser.Span s,
                                                                       boolean floorFlag)
                                                                throws ParseException

      Throws:
        `ParseException`

    - #### getPos

          protected org.apache.calcite.sql.parser.SqlParserPos getPos()
                                                               throws ParseException

      Specified by:
        `getPos` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`
      Throws:
        `ParseException`

    - #### OrderedQueryOrExpr

          public final org.apache.calcite.sql.SqlNode OrderedQueryOrExpr(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                                  throws ParseException

      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 ]

      Throws:
        `ParseException`

    - #### LeafQuery

          public final org.apache.calcite.sql.SqlNode LeafQuery(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                         throws ParseException

      Parses a leaf in a query expression (SELECT, VALUES or TABLE).

      Throws:
        `ParseException`

    - #### ParenthesizedExpression

          public final org.apache.calcite.sql.SqlNode ParenthesizedExpression(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                                       throws ParseException

      Parses a parenthesized query or single row expression.

      Throws:
        `ParseException`

    - #### ParenthesizedQueryOrCommaList

          public final org.apache.calcite.sql.SqlNodeList ParenthesizedQueryOrCommaList(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                                                 throws ParseException

      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.

      Throws:
        `ParseException`

    - #### FunctionParameterList

          public final List FunctionParameterList(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                           throws ParseException

      Parses function parameter lists including DISTINCT keyword recognition, DEFAULT, and named argument assignment.

      Throws:
        `ParseException`

    - #### Arg0

          public final void Arg0(List list,
                                 org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                          throws ParseException

      Throws:
        `ParseException`

    - #### Arg

          public final void Arg(List list,
                                org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                         throws ParseException

      Throws:
        `ParseException`

    - #### SqlQueryEof

          public final org.apache.calcite.sql.SqlNode SqlQueryEof()
                                                           throws ParseException

      Parses a query (SELECT, UNION, INTERSECT, EXCEPT, VALUES, TABLE) followed by the end-of-file symbol.

      Throws:
        `ParseException`

    - #### SqlStmt

          public final org.apache.calcite.sql.SqlNode SqlStmt()
                                                       throws ParseException

      Parses an SQL statement.

      Throws:
        `ParseException`

    - #### SqlStmtEof

          public final org.apache.calcite.sql.SqlNode SqlStmtEof()
                                                          throws ParseException

      Parses an SQL statement followed by the end-of-file symbol.

      Throws:
        `ParseException`

    - #### ColumnDefinitionList

          public final org.apache.calcite.sql.SqlNodeList ColumnDefinitionList()
                                                                        throws ParseException

      Throws:
        `ParseException`

    - #### SqlCreateTable

          public final org.apache.calcite.sql.SqlNode SqlCreateTable()
                                                              throws ParseException

      CREATE EXTERNAL TABLE ( IF NOT EXISTS )? ( database_name ‘.’ )? table_name ( ‘(’ column_def ( ‘,’ column_def )* ‘)’ ( STORED AS INPUTFORMAT input_format_classname OUTPUTFORMAT output_format_classname )? LOCATION location_uri ( TBLPROPERTIES tbl_properties )? ( AS select_stmt )

      Throws:
        `ParseException`

    - #### SqlCreateFunction

          public final org.apache.calcite.sql.SqlNode SqlCreateFunction()
                                                                 throws ParseException

      CREATE FUNCTION functionname AS ‘classname’

      Throws:
        `ParseException`

    - #### SqlSelect

          public final org.apache.calcite.sql.SqlSelect SqlSelect()
                                                           throws ParseException

      Parses a leaf SELECT expression without ORDER BY.

      Throws:
        `ParseException`

    - #### SqlExplain

          public final org.apache.calcite.sql.SqlNode SqlExplain()
                                                          throws ParseException

      Parses an EXPLAIN PLAN statement.

      Throws:
        `ParseException`

    - #### SqlQueryOrDml

          public final org.apache.calcite.sql.SqlNode SqlQueryOrDml()
                                                             throws ParseException

      Parses a query (SELECT or VALUES) or DML statement (INSERT, UPDATE, DELETE, MERGE).

      Throws:
        `ParseException`

    - #### ExplainDepth

          public final org.apache.calcite.sql.SqlExplain.Depth ExplainDepth()
                                                                     throws ParseException

      Parses WITH TYPE | WITH IMPLEMENTATION | WITHOUT IMPLEMENTATION modifier for EXPLAIN PLAN.

      Throws:
        `ParseException`

    - #### ExplainDetailLevel

          public final org.apache.calcite.sql.SqlExplainLevel ExplainDetailLevel()
                                                                          throws ParseException

      Parses INCLUDING ALL ATTRIBUTES modifier for EXPLAIN PLAN.

      Throws:
        `ParseException`

    - #### SqlDescribe

          public final org.apache.calcite.sql.SqlNode SqlDescribe()
                                                           throws ParseException

      Parses a DESCRIBE statement.

      Throws:
        `ParseException`

    - #### SqlProcedureCall

          public final org.apache.calcite.sql.SqlNode SqlProcedureCall()
                                                                throws ParseException

      Parses a CALL statement.

      Throws:
        `ParseException`

    - #### NamedRoutineCall

          public final org.apache.calcite.sql.SqlNode NamedRoutineCall(org.apache.calcite.sql.SqlFunctionCategory routineType,
                                                                       org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                                throws ParseException

      Throws:
        `ParseException`

    - #### SqlInsert

          public final org.apache.calcite.sql.SqlNode SqlInsert()
                                                         throws ParseException

      Parses an INSERT statement.

      Throws:
        `ParseException`

    - #### SqlDelete

          public final org.apache.calcite.sql.SqlNode SqlDelete()
                                                         throws ParseException

      Parses a DELETE statement.

      Throws:
        `ParseException`

    - #### SqlUpdate

          public final org.apache.calcite.sql.SqlNode SqlUpdate()
                                                         throws ParseException

      Parses an UPDATE statement.

      Throws:
        `ParseException`

    - #### SqlMerge

          public final org.apache.calcite.sql.SqlNode SqlMerge()
                                                        throws ParseException

      Parses a MERGE statement.

      Throws:
        `ParseException`

    - #### WhenMatchedClause

          public final org.apache.calcite.sql.SqlUpdate WhenMatchedClause(org.apache.calcite.sql.SqlNode table,
                                                                          org.apache.calcite.sql.SqlIdentifier alias)
                                                                   throws ParseException

      Throws:
        `ParseException`

    - #### WhenNotMatchedClause

          public final org.apache.calcite.sql.SqlInsert WhenNotMatchedClause(org.apache.calcite.sql.SqlNode table)
                                                                      throws ParseException

      Throws:
        `ParseException`

    - #### SelectList

          public final List<org.apache.calcite.sql.SqlNode> SelectList()
                                                                throws ParseException

      Parses the select list of a SELECT statement.

      Throws:
        `ParseException`

    - #### SelectItem

          public final org.apache.calcite.sql.SqlNode SelectItem()
                                                          throws ParseException

      Parses one item in a select list.

      Throws:
        `ParseException`

    - #### SelectExpression

          public final org.apache.calcite.sql.SqlNode SelectExpression()
                                                                throws ParseException

      Parses one unaliased expression in a select list.

      Throws:
        `ParseException`

    - #### Natural

          public final org.apache.calcite.sql.SqlLiteral Natural()
                                                          throws ParseException

      Throws:
        `ParseException`

    - #### JoinType

          public final org.apache.calcite.sql.SqlLiteral JoinType()
                                                           throws ParseException

      Throws:
        `ParseException`

    - #### JoinTable

          public final org.apache.calcite.sql.SqlNode JoinTable(org.apache.calcite.sql.SqlNode e)
                                                         throws ParseException

      Matches “LEFT JOIN t ON …”, “RIGHT JOIN t USING …”, “JOIN t”.

      Throws:
        `ParseException`

    - #### FromClause

          public final org.apache.calcite.sql.SqlNode FromClause()
                                                          throws ParseException

      Parses the FROM clause for a SELECT.

      FROM is mandatory in standard SQL, optional in dialects such as MySQL, PostgreSQL. The parser allows SELECT without FROM, but the validator fails if conformance is, say, STRICT_2003.

      Throws:
        `ParseException`

    - #### TableRef

          public final org.apache.calcite.sql.SqlNode TableRef()
                                                        throws ParseException

      Parses a table reference in a FROM clause, not lateral unless LATERAL is explicitly specified.

      Throws:
        `ParseException`

    - #### TableRef2

          public final org.apache.calcite.sql.SqlNode TableRef2(boolean lateral)
                                                         throws ParseException

      Parses a table reference in a FROM clause.

      Throws:
        `ParseException`

    - #### ExtendList

          public final org.apache.calcite.sql.SqlNodeList ExtendList()
                                                              throws ParseException

      Throws:
        `ParseException`

    - #### ColumnType

          public final void ColumnType(List<org.apache.calcite.sql.SqlNode> list)
                                throws ParseException

      Throws:
        `ParseException`

    - #### CompoundIdentifierType

          public final void CompoundIdentifierType(List<org.apache.calcite.sql.SqlNode> list,
                                                   List<org.apache.calcite.sql.SqlNode> extendList)
                                            throws ParseException

      Parses a compound identifier with optional type.

      Throws:
        `ParseException`

    - #### TableFunctionCall

          public final org.apache.calcite.sql.SqlNode TableFunctionCall(org.apache.calcite.sql.parser.SqlParserPos pos)
                                                                 throws ParseException

      Throws:
        `ParseException`

    - #### ExplicitTable

          public final org.apache.calcite.sql.SqlNode ExplicitTable(org.apache.calcite.sql.parser.SqlParserPos pos)
                                                             throws ParseException

      Parses an explicit TABLE t reference.

      Throws:
        `ParseException`

    - #### TableConstructor

          public final org.apache.calcite.sql.SqlNode TableConstructor()
                                                                throws ParseException

      Parses a VALUES leaf query expression.

      Throws:
        `ParseException`

    - #### RowConstructorList

          public final org.apache.calcite.sql.SqlNodeList RowConstructorList(org.apache.calcite.sql.parser.Span s)
                                                                      throws ParseException

      Parses one or more rows in a VALUES expression.

      Throws:
        `ParseException`

    - #### RowConstructor

          public final org.apache.calcite.sql.SqlNode RowConstructor()
                                                              throws ParseException

      Parses a row constructor in the context of a VALUES expression.

      Throws:
        `ParseException`

    - #### WhereOpt

          public final org.apache.calcite.sql.SqlNode WhereOpt()
                                                        throws ParseException

      Parses the optional WHERE clause for SELECT, DELETE, and UPDATE.

      Throws:
        `ParseException`

    - #### GroupByOpt

          public final org.apache.calcite.sql.SqlNodeList GroupByOpt()
                                                              throws ParseException

      Parses the optional GROUP BY clause for SELECT.

      Throws:
        `ParseException`

    - #### GroupingElementList

          public final List<org.apache.calcite.sql.SqlNode> GroupingElementList()
                                                                         throws ParseException

      Throws:
        `ParseException`

    - #### GroupingElement

          public final org.apache.calcite.sql.SqlNode GroupingElement()
                                                               throws ParseException

      Throws:
        `ParseException`

    - #### ExpressionCommaList

          public final org.apache.calcite.sql.SqlNodeList ExpressionCommaList(org.apache.calcite.sql.parser.Span s,
                                                                              org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                                       throws ParseException

      Parses a list of expressions separated by commas.

      Throws:
        `ParseException`

    - #### HavingOpt

          public final org.apache.calcite.sql.SqlNode HavingOpt()
                                                         throws ParseException

      Parses the optional HAVING clause for SELECT.

      Throws:
        `ParseException`

    - #### WindowOpt

          public final org.apache.calcite.sql.SqlNodeList WindowOpt()
                                                             throws ParseException

      Parses the optional WINDOW clause for SELECT

      Throws:
        `ParseException`

    - #### WindowSpecification

          public final org.apache.calcite.sql.SqlWindow WindowSpecification()
                                                                     throws ParseException

      Parses a window specification.

      Throws:
        `ParseException`

    - #### WindowRange

          public final org.apache.calcite.sql.SqlNode WindowRange()
                                                           throws ParseException

      Throws:
        `ParseException`

    - #### OrderBy

          public final org.apache.calcite.sql.SqlNodeList OrderBy(boolean accept)
                                                           throws ParseException

      Parses an ORDER BY clause.

      Throws:
        `ParseException`

    - #### OrderItem

          public final org.apache.calcite.sql.SqlNode OrderItem()
                                                         throws ParseException

      Parses one list item in an ORDER BY clause.

      Throws:
        `ParseException`

    - #### MatchRecognizeOpt

          public final org.apache.calcite.sql.SqlMatchRecognize MatchRecognizeOpt(org.apache.calcite.sql.SqlNode tableRef)
                                                                           throws ParseException

      Parses a MATCH_RECOGNIZE clause following a table expression.

      Throws:
        `ParseException`

    - #### MeasureColumnCommaList

          public final org.apache.calcite.sql.SqlNodeList MeasureColumnCommaList(org.apache.calcite.sql.parser.Span s)
                                                                          throws ParseException

      Throws:
        `ParseException`

    - #### MeasureColumn

          public final org.apache.calcite.sql.SqlNode MeasureColumn()
                                                             throws ParseException

      Throws:
        `ParseException`

    - #### PatternExpression

          public final org.apache.calcite.sql.SqlNode PatternExpression()
                                                                 throws ParseException

      Throws:
        `ParseException`

    - #### PatternTerm

          public final org.apache.calcite.sql.SqlNode PatternTerm()
                                                           throws ParseException

      Throws:
        `ParseException`

    - #### PatternFactor

          public final org.apache.calcite.sql.SqlNode PatternFactor()
                                                             throws ParseException

      Throws:
        `ParseException`

    - #### PatternPrimary

          public final org.apache.calcite.sql.SqlNode PatternPrimary()
                                                              throws ParseException

      Throws:
        `ParseException`

    - #### SubsetDefinitionCommaList

          public final org.apache.calcite.sql.SqlNodeList SubsetDefinitionCommaList(org.apache.calcite.sql.parser.Span s)
                                                                             throws ParseException

      Throws:
        `ParseException`

    - #### SubsetDefinition

          public final org.apache.calcite.sql.SqlNode SubsetDefinition()
                                                                throws ParseException

      Throws:
        `ParseException`

    - #### PatternDefinitionCommaList

          public final org.apache.calcite.sql.SqlNodeList PatternDefinitionCommaList(org.apache.calcite.sql.parser.Span s)
                                                                              throws ParseException

      Throws:
        `ParseException`

    - #### PatternDefinition

          public final org.apache.calcite.sql.SqlNode PatternDefinition()
                                                                 throws ParseException

      Throws:
        `ParseException`

    - #### SqlExpressionEof

          public final org.apache.calcite.sql.SqlNode SqlExpressionEof()
                                                                throws ParseException

      Parses a SQL expression (such as might occur in a WHERE clause) followed by the end-of-file symbol.

      Throws:
        `ParseException`

    - #### QueryOrExpr

          public final org.apache.calcite.sql.SqlNode QueryOrExpr(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                           throws ParseException

      Parses either a row expression or a query expression without ORDER BY.

      Throws:
        `ParseException`

    - #### WithList

          public final org.apache.calcite.sql.SqlNodeList WithList()
                                                            throws ParseException

      Throws:
        `ParseException`

    - #### WithItem

          public final org.apache.calcite.sql.SqlWithItem WithItem()
                                                            throws ParseException

      Throws:
        `ParseException`

    - #### LeafQueryOrExpr

          public final org.apache.calcite.sql.SqlNode LeafQueryOrExpr(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                               throws ParseException

      Parses either a row expression, a leaf query expression, or a parenthesized expression of any kind.

      Throws:
        `ParseException`

    - #### Expression

          public final org.apache.calcite.sql.SqlNode Expression(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                          throws ParseException

      Parses a row expression or a parenthesized expression of any kind.

      Throws:
        `ParseException`

    - #### Expression2b

          public final void Expression2b(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext,
                                         List<Object> list)
                                  throws ParseException

      Throws:
        `ParseException`

    - #### Expression2

          public final List<Object> Expression2(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                         throws ParseException

      Parses a binary row expression, or a parenthesized expression of any kind.

      The result is as a flat list of operators and operands. The top-level call to get an expression should call `Expression(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext)`, but lower-level calls should call this, to give the parser the opportunity to associate operator calls.

      For example ‘a = b like c = d’ should come out ‘((a = b) like c) = d’ because LIKE and ‘=’ have the same precedence, but tends to come out as ‘(a = b) like (c = d)’ because (a = b) and (c = d) are parsed as separate expressions.

      Throws:
        `ParseException`

    - #### comp

          public final org.apache.calcite.sql.SqlKind comp()
                                                    throws ParseException

      Parses a comparison operator inside a SOME / ALL predicate.

      Throws:
        `ParseException`

    - #### Expression3

          public final org.apache.calcite.sql.SqlNode Expression3(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                           throws ParseException

      Parses a unary row expression, or a parenthesized expression of any kind.

      Throws:
        `ParseException`

    - #### periodOperator

          public final org.apache.calcite.sql.SqlOperator periodOperator()
                                                                  throws ParseException

      Throws:
        `ParseException`

    - #### CollateClause

          public final org.apache.calcite.sql.SqlCollation CollateClause()
                                                                  throws ParseException

      Parses a COLLATE clause

      Throws:
        `ParseException`

    - #### AtomicRowExpression

          public final org.apache.calcite.sql.SqlNode AtomicRowExpression()
                                                                   throws ParseException

      Parses an atomic row expression.

      Throws:
        `ParseException`

    - #### CaseExpression

          public final org.apache.calcite.sql.SqlNode CaseExpression()
                                                              throws ParseException

      Throws:
        `ParseException`

    - #### SequenceExpression

          public final org.apache.calcite.sql.SqlCall SequenceExpression()
                                                                  throws ParseException

      Throws:
        `ParseException`

    - #### SqlSetOption

          public final org.apache.calcite.sql.SqlSetOption SqlSetOption(org.apache.calcite.sql.parser.Span s,
                                                                        String scope)
                                                                 throws ParseException

      Parses “SET <NAME> = VALUE” or “RESET <NAME>”, without a leading “ALTER <SCOPE>”.

      Throws:
        `ParseException`

    - #### SqlAlter

          public final org.apache.calcite.sql.SqlAlter SqlAlter()
                                                         throws ParseException

      Parses an expression for setting or resetting an option in SQL, such as QUOTED_IDENTIFIERS, or explain plan level (physical/logical).

      Throws:
        `ParseException`

    - #### Scope

          public final String Scope()
                             throws ParseException

      Throws:
        `ParseException`

    - #### Literal

          public final org.apache.calcite.sql.SqlNode Literal()
                                                       throws ParseException

      Parses a literal expression, allowing continued string literals. Usually returns an SqlLiteral, but a continued string literal is an SqlCall expression, which concatenates 2 or more string literals; the validator reduces this.

      Throws:
        `ParseException`

    - #### UnsignedNumericLiteral

          public final org.apache.calcite.sql.SqlNumericLiteral UnsignedNumericLiteral()
                                                                                throws ParseException

      Parses a unsigned numeric literal

      Throws:
        `ParseException`

    - #### NumericLiteral

          public final org.apache.calcite.sql.SqlLiteral NumericLiteral()
                                                                 throws ParseException

      Parses a numeric literal (can be signed)

      Throws:
        `ParseException`

    - #### SpecialLiteral

          public final org.apache.calcite.sql.SqlLiteral SpecialLiteral()
                                                                 throws ParseException

      Parse a special literal keyword

      Throws:
        `ParseException`

    - #### StringLiteral

          public final org.apache.calcite.sql.SqlNode StringLiteral()
                                                             throws ParseException

      Parses a string literal. The literal may be continued onto several lines. For a simple literal, the result is an SqlLiteral. For a continued literal, the result is an SqlCall expression, which concatenates 2 or more string literals; the validator reduces this.

      Returns:
        a literal expression
      Throws:
        `ParseException`
      See Also:
        `SqlLiteral.unchain(SqlNode)`, `SqlLiteral.stringValue(SqlNode)`

    - #### DateTimeLiteral

          public final org.apache.calcite.sql.SqlLiteral DateTimeLiteral()
                                                                  throws ParseException

      Parses a date/time literal.

      Throws:
        `ParseException`

    - #### MultisetConstructor

          public final org.apache.calcite.sql.SqlNode MultisetConstructor()
                                                                   throws ParseException

      Parses a MULTISET constructor

      Throws:
        `ParseException`

    - #### ArrayConstructor

          public final org.apache.calcite.sql.SqlNode ArrayConstructor()
                                                                throws ParseException

      Parses an ARRAY constructor

      Throws:
        `ParseException`

    - #### MapConstructor

          public final org.apache.calcite.sql.SqlNode MapConstructor()
                                                              throws ParseException

      Parses a MAP constructor

      Throws:
        `ParseException`

    - #### PeriodConstructor

          public final org.apache.calcite.sql.SqlNode PeriodConstructor()
                                                                 throws ParseException

      Parses a PERIOD constructor

      Throws:
        `ParseException`

    - #### IntervalLiteral

          public final org.apache.calcite.sql.SqlLiteral IntervalLiteral()
                                                                  throws ParseException

      Parses an interval literal.

      Throws:
        `ParseException`

    - #### IntervalQualifier

          public final org.apache.calcite.sql.SqlIntervalQualifier IntervalQualifier()
                                                                              throws ParseException

      Throws:
        `ParseException`

    - #### TimeUnit

          public final org.apache.calcite.avatica.util.TimeUnit TimeUnit()
                                                                  throws ParseException

      Parses time unit for EXTRACT, CEIL and FLOOR functions.

      Throws:
        `ParseException`

    - #### TimestampInterval

          public final org.apache.calcite.avatica.util.TimeUnit TimestampInterval()
                                                                           throws ParseException

      Throws:
        `ParseException`

    - #### DynamicParam

          public final org.apache.calcite.sql.SqlDynamicParam DynamicParam()
                                                                    throws ParseException

      Parses a dynamic parameter marker.

      Throws:
        `ParseException`

    - #### Identifier

          public final String Identifier()
                                  throws ParseException

      Parses a simple identifier as a string.

      Throws:
        `ParseException`

    - #### SimpleIdentifier

          public final org.apache.calcite.sql.SqlIdentifier SimpleIdentifier()
                                                                      throws ParseException

      Parses a simple identifier as an SqlIdentifier.

      Throws:
        `ParseException`

    - #### SimpleIdentifierCommaList

          public final void SimpleIdentifierCommaList(List<org.apache.calcite.sql.SqlNode> list)
                                               throws ParseException

      Parses a comma-separated list of simple identifiers.

      Throws:
        `ParseException`

    - #### ParenthesizedSimpleIdentifierList

          public final org.apache.calcite.sql.SqlNodeList ParenthesizedSimpleIdentifierList()
                                                                                     throws ParseException

      List of simple identifiers in parentheses. The position extends from the open parenthesis to the close parenthesis.

      Throws:
        `ParseException`

    - #### CompoundIdentifier

          public final org.apache.calcite.sql.SqlIdentifier CompoundIdentifier()
                                                                        throws ParseException

      Parses a compound identifier.

      Throws:
        `ParseException`

    - #### CompoundIdentifierTypeCommaList

          public final void CompoundIdentifierTypeCommaList(List<org.apache.calcite.sql.SqlNode> list,
                                                            List<org.apache.calcite.sql.SqlNode> extendList)
                                                     throws ParseException

      Parses a comma-separated list of compound identifiers.

      Throws:
        `ParseException`

    - #### ParenthesizedCompoundIdentifierList

          public final org.apache.calcite.util.Pair<org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNodeList> ParenthesizedCompoundIdentifierList()
                                                                                                                                                        throws ParseException

      List of compound identifiers in parentheses. The position extends from the open parenthesis to the close parenthesis.

      Throws:
        `ParseException`

    - #### NewSpecification

          public final org.apache.calcite.sql.SqlNode NewSpecification()
                                                                throws ParseException

      Parses a NEW UDT(…) expression.

      Throws:
        `ParseException`

    - #### UnsignedIntLiteral

          public final int UnsignedIntLiteral()
                                       throws ParseException

      Throws:
        `ParseException`

    - #### IntLiteral

          public final int IntLiteral()
                               throws ParseException

      Throws:
        `ParseException`

    - #### DataType

          public final org.apache.calcite.sql.SqlDataTypeSpec DataType()
                                                                throws ParseException

      Throws:
        `ParseException`

    - #### TypeName

          public final org.apache.calcite.sql.SqlIdentifier TypeName()
                                                              throws ParseException

      Throws:
        `ParseException`

    - #### SqlTypeName

          public final org.apache.calcite.sql.type.SqlTypeName SqlTypeName(org.apache.calcite.sql.parser.Span s)
                                                                    throws ParseException

      Throws:
        `ParseException`

    - #### JdbcOdbcDataTypeName

          public final org.apache.calcite.sql.SqlJdbcDataTypeName JdbcOdbcDataTypeName()
                                                                                throws ParseException

      Throws:
        `ParseException`

    - #### JdbcOdbcDataType

          public final org.apache.calcite.sql.SqlLiteral JdbcOdbcDataType()
                                                                   throws ParseException

      Throws:
        `ParseException`

    - #### CollectionsTypeName

          public final org.apache.calcite.sql.SqlIdentifier CollectionsTypeName()
                                                                         throws ParseException

      Throws:
        `ParseException`

    - #### CursorExpression

          public final org.apache.calcite.sql.SqlNode CursorExpression(org.apache.calcite.sql.parser.SqlAbstractParserImpl.ExprContext exprContext)
                                                                throws ParseException

      Parses a CURSOR(query) expression. The parser allows these anywhere, but the validator restricts them to appear only as arguments to table functions.

      Throws:
        `ParseException`

    - #### BuiltinFunctionCall

          public final org.apache.calcite.sql.SqlNode BuiltinFunctionCall()
                                                                   throws ParseException

      Parses a call to a builtin function with special syntax.

      Throws:
        `ParseException`

    - #### TimestampAddFunctionCall

          public final org.apache.calcite.sql.SqlCall TimestampAddFunctionCall()
                                                                        throws ParseException

      Parses a call to TIMESTAMPADD.

      Throws:
        `ParseException`

    - #### TimestampDiffFunctionCall

          public final org.apache.calcite.sql.SqlCall TimestampDiffFunctionCall()
                                                                         throws ParseException

      Parses a call to TIMESTAMPDIFF.

      Throws:
        `ParseException`

    - #### MatchRecognizeFunctionCall

          public final org.apache.calcite.sql.SqlCall MatchRecognizeFunctionCall()
                                                                          throws ParseException

      Throws:
        `ParseException`

    - #### MatchRecognizeCallWithModifier

          public final org.apache.calcite.sql.SqlCall MatchRecognizeCallWithModifier()
                                                                              throws ParseException

      Throws:
        `ParseException`

    - #### MatchRecognizeNavigationLogical

          public final org.apache.calcite.sql.SqlCall MatchRecognizeNavigationLogical()
                                                                               throws ParseException

      Throws:
        `ParseException`

    - #### MatchRecognizeNavigationPhysical

          public final org.apache.calcite.sql.SqlCall MatchRecognizeNavigationPhysical()
                                                                                throws ParseException

      Throws:
        `ParseException`

    - #### NamedFunctionCall

          public final org.apache.calcite.sql.SqlNode NamedFunctionCall()
                                                                 throws ParseException

      Parses a call to a named function (could be a builtin with regular syntax, or else a UDF).

      NOTE: every UDF has two names: an invocation name and a specific name. Normally, function calls are resolved via overload resolution and invocation names. The SPECIFIC prefix allows overload resolution to be bypassed. Note that usage of the SPECIFIC prefix in queries is non-standard; it is used internally by Farrago, e.g. in stored view definitions to permanently bind references to a particular function after the overload resolution performed by view creation.

      TODO jvs 25-Mar-2005: Once we have SQL-Flagger support, flag SPECIFIC as non-standard.

      Throws:
        `ParseException`

    - #### StandardFloorCeilOptions

          public final org.apache.calcite.sql.SqlNode StandardFloorCeilOptions(org.apache.calcite.sql.parser.Span s,
                                                                               boolean floorFlag)
                                                                        throws ParseException

      Throws:
        `ParseException`

    - #### NonReservedJdbcFunctionName

          public final String NonReservedJdbcFunctionName()
                                                   throws ParseException

      Parses the name of a JDBC function that is a token but is not reserved.

      Throws:
        `ParseException`

    - #### FunctionName

          public final org.apache.calcite.sql.SqlIdentifier FunctionName()
                                                                  throws ParseException

      Parses the name of a function (either a compound identifier or a reserved word which can be used as a function name).

      Throws:
        `ParseException`

    - #### ReservedFunctionName

          public final org.apache.calcite.sql.SqlIdentifier ReservedFunctionName()
                                                                          throws ParseException

      Parses a reserved word which is used as the name of a function.

      Throws:
        `ParseException`

    - #### ContextVariable

          public final org.apache.calcite.sql.SqlIdentifier ContextVariable()
                                                                     throws ParseException

      Throws:
        `ParseException`

    - #### JdbcFunctionCall

          public final org.apache.calcite.sql.SqlNode JdbcFunctionCall()
                                                                throws ParseException

      Parses a function call expression with JDBC syntax.

      Throws:
        `ParseException`

    - #### BinaryQueryOperator

          public final org.apache.calcite.sql.SqlBinaryOperator BinaryQueryOperator()
                                                                             throws ParseException

      Parses a binary query operator like UNION.

      Throws:
        `ParseException`

    - #### BinaryMultisetOperator

          public final org.apache.calcite.sql.SqlBinaryOperator BinaryMultisetOperator()
                                                                                throws ParseException

      Parses a binary multiset operator.

      Throws:
        `ParseException`

    - #### BinaryRowOperator

          public final org.apache.calcite.sql.SqlBinaryOperator BinaryRowOperator()
                                                                           throws ParseException

      Parses a binary row operator like AND.

      Throws:
        `ParseException`

    - #### PrefixRowOperator

          public final org.apache.calcite.sql.SqlPrefixOperator PrefixRowOperator()
                                                                           throws ParseException

      Parses a prefix row operator like NOT.

      Throws:
        `ParseException`

    - #### PostfixRowOperator

          public final org.apache.calcite.sql.SqlPostfixOperator PostfixRowOperator()
                                                                             throws ParseException

      Parses a postfix row operator like IS NOT NULL.

      Throws:
        `ParseException`

    - #### CommonNonReservedKeyWord

          public final String CommonNonReservedKeyWord()
                                                throws ParseException

      Parses a non-reserved keyword for use as an identifier. Specializations of this parser can use this as a base for implementing the NonReservedKeyWord() production.

      When adding keywords to this list, be sure that they are not reserved by the SQL:2003 standard (see productions for “non-reserved word” and “reserved word” in reference below).

      Throws:
        `ParseException`
      See Also:
        `SQL:2003 Part 2 Section 5.2`

    - #### UnusedExtension

          public final void UnusedExtension()
                                     throws ParseException

      Defines a production which can never be accepted by the parser. In effect, it tells the parser, “If you got here, you’ve gone too far.” It is used as the default production for parser extension points; derived parsers replace it with a real production when they want to implement a particular extension point.

      Throws:
        `ParseException`

    - #### ReInit

          public void ReInit(InputStream stream)

    - #### ReInit

          public void ReInit(InputStream stream,
                             String encoding)

    - #### ReInit

          public void ReInit(Reader stream)

      Specified by:
        `ReInit` in class `org.apache.calcite.sql.parser.SqlAbstractParserImpl`

    - #### ReInit

          public void ReInit(StormParserImplTokenManager tm)

    - #### getNextToken

          public final Token getNextToken()

    - #### getToken

          public final Token getToken(int index)

    - #### generateParseException

          public ParseException generateParseException()

    - #### enable_tracing

          public final void enable_tracing()

    - #### disable_tracing

          public final void disable_tracing()

Copyright © 2021 The Apache Software Foundation. All rights reserved.