// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License. You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied. See the License for the

// specific language governing permissions and limitations

// under the License.

// This file is copied from

// https://github.com/cloudera/Impala/blob/v0.7refresh/fe/src/main/cup/sql-parser.y

// and modified by Doris

package org.apache.doris.analysis;

import java.math.BigDecimal;

import java.util.AbstractMap;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.HashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import org.apache.doris.analysis.AlterDatabaseQuotaStmt.QuotaType;

import org.apache.doris.analysis.SetOperationStmt.Qualifier;

import org.apache.doris.analysis.SetOperationStmt.Operation;

import org.apache.doris.analysis.SetOperationStmt.SetOperand;

import org.apache.doris.analysis.LoadType;

import org.apache.doris.catalog.AccessPrivilege;

import org.apache.doris.catalog.AccessPrivilegeWithCols;

import org.apache.doris.catalog.AggregateType;

import org.apache.doris.catalog.KeysType;

import org.apache.doris.catalog.PrimitiveType;

import org.apache.doris.catalog.ScalarType;

import org.apache.doris.catalog.Type;

import org.apache.doris.catalog.ArrayType;

import org.apache.doris.catalog.MapType;

import org.apache.doris.catalog.StructField;

import org.apache.doris.catalog.StructType;

import org.apache.doris.catalog.TableIf.TableType;

import org.apache.doris.catalog.View;

import org.apache.doris.common.AnalysisException;

import org.apache.doris.common.Config;

import org.apache.doris.common.FeConstants;

import org.apache.doris.common.Version;

import org.apache.doris.mysql.MysqlPassword;

import org.apache.doris.load.loadv2.LoadTask;

import org.apache.doris.policy.PolicyTypeEnum;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import java_cup.runtime.Symbol;

// Commented by Zhao Chun

// Now we have 2 shift/reduce conflict

// between TIMESTAMP "20100101" and TIMESTAMP "alias"

// between DATE "20100101" and DATE "alias"

parser code {:

private Symbol errorToken;

public boolean isVerbose = false;

public String wild;

public Expr where;

public ArrayList<PlaceHolderExpr> placeholder_expr_list = Lists.newArrayList();

// List of expected tokens ids from current parsing state for generating syntax error message

private final List<Integer> expectedTokenIds = Lists.newArrayList();

// To avoid reporting trivial tokens as expected tokens in error messages

private boolean reportExpectedToken(Integer tokenId) {

if (SqlScanner.isKeyword(tokenId) ||

tokenId.intValue() == SqlParserSymbols.COMMA ||

tokenId.intValue() == SqlParserSymbols.DOT ||

tokenId.intValue() == SqlParserSymbols.IDENT) {

return true;

} else {

return false;

}

}

private String getErrorTypeMessage(int lastTokenId) {

String msg = null;

switch(lastTokenId) {

case SqlParserSymbols.UNMATCHED_STRING_LITERAL:

msg = "Unmatched string literal";

break;

case SqlParserSymbols.NUMERIC_OVERFLOW:

msg = "Numeric overflow";

break;

default:

msg = "Syntax error";

break;

}

return msg;

}

// Override to save error token, just update error information.

@Override

public void syntax_error(Symbol token) {

errorToken = token;

// derive expected tokens from current parsing state

expectedTokenIds.clear();

int state = ((Symbol)stack.peek()).parse_state;

// get row of actions table corresponding to current parsing state

// the row consists of pairs of <tokenId, actionId>

// a pair is stored as row[i] (tokenId) and row[i+1] (actionId)

// the last pair is a special error action

short[] row = action_tab[state];

short tokenId;

// the expected tokens are all the symbols with a

// corresponding action from the current parsing state

for (int i = 0; i < row.length-2; ++i) {

// Get tokenId and skip actionId

tokenId = row[i++];

expectedTokenIds.add(Integer.valueOf(tokenId));

}

}

// Override to keep it from calling report_fatal_error()

// This exception is not AnalysisException because we don't want this report to client.

@Override

public void unrecovered_syntax_error(Symbol cur_token) throws AnalysisException {

throw new AnalysisException(getErrorTypeMessage(cur_token.sym));

}

// Manually throw a parse error on a given symbol for special circumstances.

public void parseError(String symbolName, int symbolId) throws AnalysisException {

Symbol errorToken = getSymbolFactory().newSymbol(symbolName, symbolId,

((Symbol) stack.peek()), ((Symbol) stack.peek()), null);

// Call syntax error to gather information about expected tokens, etc.

// syntax_error does not throw an exception

syntax_error(errorToken);

unrecovered_syntax_error(errorToken);

}

// Returns error string, consisting of the original

// stmt with a '^' under the offending token. Assumes

// that parse() has been called and threw an exception

public String getErrorMsg(String stmt) {

if (errorToken == null || stmt == null) {

return null;

}

String[] lines = stmt.split("\n", -1);

StringBuilder result = new StringBuilder();

result.append(getErrorTypeMessage(errorToken.sym) + " in line ");

result.append(errorToken.left);

result.append(":\n");

// errorToken_.left is the line number of error.

// errorToken_.right is the column number of the error.

// index is start from 0, so "minus 1" is the real error line idx

String errorLine = lines[errorToken.left - 1];

// If the error is that additional tokens are expected past the end,

// errorToken_.right will be past the end of the string.

int lastCharIndex = Math.min(errorLine.length(), errorToken.right);

int maxPrintLength = 60;

int errorLoc = 0;

if (errorLine.length() <= maxPrintLength) {

// The line is short. Print the entire line.

result.append(errorLine);

result.append('\n');

errorLoc = errorToken.right;

} else {

// The line is too long. Print maxPrintLength/2 characters before the error and

// after the error.

int contextLength = maxPrintLength / 2 - 3;

String leftSubStr;

if (errorToken.right > maxPrintLength / 2) {

leftSubStr = "..." + errorLine.substring(errorToken.right - contextLength,

lastCharIndex);

} else {

leftSubStr = errorLine.substring(0, errorToken.right);

}

errorLoc = leftSubStr.length();

result.append(leftSubStr);

if (errorLine.length() - errorToken.right > maxPrintLength / 2) {

result.append(errorLine.substring(errorToken.right,

errorToken.right + contextLength) + "...");

} else {

result.append(errorLine.substring(lastCharIndex));

}

result.append("\n");

}

// print error indicator

for (int i = 0; i < errorLoc - 1; ++i) {

result.append(' ');

}

result.append("^\n");

// only report encountered and expected tokens for syntax errors

if (errorToken.sym == SqlParserSymbols.UNMATCHED_STRING_LITERAL ||

errorToken.sym == SqlParserSymbols.NUMERIC_OVERFLOW) {

return result.toString();

}

// append last encountered token

result.append("Encountered: ");

String lastToken = SqlScanner.tokenIdMap.get(Integer.valueOf(errorToken.sym));

if (lastToken != null) {

result.append(lastToken);

} else if (SqlScanner.isKeyword((String) errorToken.value)) {

result.append("A reserved word cannot be used as an identifier: ").append((String) errorToken.value);

} else {

result.append("Unknown last token with id: " + errorToken.sym);

}

// Append expected tokens

result.append('\n');

result.append("Expected: ");

String expectedToken = null;

Integer tokenId = null;

for (int i = 0; i < expectedTokenIds.size(); ++i) {

tokenId = expectedTokenIds.get(i);

// keywords hints

if (SqlScanner.isKeyword(lastToken) && tokenId.intValue() == SqlParserSymbols.IDENT) {

result.append(String.format("%s is keyword, maybe `%s`", lastToken, lastToken) + ", ");

continue;

}

if (reportExpectedToken(tokenId)) {

expectedToken = SqlScanner.tokenIdMap.get(tokenId);

result.append(expectedToken + ", ");

}

}

// remove trailing ", "

result.delete(result.length() - 2, result.length());

result.append('\n');

return result.toString();

}

:};

// Total keywords of doris, keep them in lexicographical order

terminal String

KW_ACCOUNT_LOCK,

KW_ACCOUNT_UNLOCK,

KW_ADD,

KW_ADMIN,

KW_AFTER,

KW_AGGREGATE,

KW_ALIAS,

KW_ALL,

KW_ALTER,

KW_ANALYZE,

KW_AND,

KW_ANTI,

KW_APPEND,

KW_ARRAY,

KW_AUTO_INCREMENT,

KW_AS,

KW_ASC,

KW_AUTHORS,

KW_BACKEND,

KW_BACKENDS,

KW_BACKUP,

KW_BEGIN,

KW_BELONG,

KW_BETWEEN,

KW_BIGINT,

KW_BIN,

KW_BINLOG,

KW_BITMAP,

KW_BITMAP_UNION,

KW_BLOB,

KW_BOOLEAN,

KW_BRIEF,

KW_BROKER,

KW_BUCKETS,

KW_BUILD,

KW_BUILTIN,

KW_BY,

KW_CACHED,

KW_CANCEL,

KW_CASE,

KW_CAST,

KW_CATALOG,

KW_CATALOGS,

KW_CHAIN,

KW_CHAR,

KW_CHARSET,

KW_CHECK,

KW_CLEAN,

KW_CLUSTER,

KW_CLUSTERS,

KW_COLLATE,

KW_COLLATION,

KW_COLUMN,

KW_COLUMNS,

KW_COMMENT,

KW_COMMIT,

KW_COMMITTED,

KW_COMPACT,

KW_COMPLETE,

KW_COMPRESS_TYPE,

KW_CONFIG,

KW_CONNECTION,

KW_CONNECTION_ID,

KW_CONSISTENT,

KW_CONVERT,

KW_COPY,

KW_COUNT,

KW_CREATE,

KW_CREATION,

KW_CROSS,

KW_CUBE,

KW_CURRENT,

KW_CURRENT_CATALOG,

KW_CURRENT_TIMESTAMP,

KW_CURRENT_USER,

KW_DATA,

KW_DATABASE,

KW_DATABASES,

KW_DATE,

KW_DATETIME,

KW_DATETIMEV2,

KW_DATEV2,

KW_DATETIMEV1,

KW_DATEV1,

KW_DAY,

KW_DECIMAL,

KW_DECIMALV2,

KW_DECIMALV3,

KW_DECOMMISSION,

KW_DEFAULT,

KW_DEFERRED,

KW_DELETE,

KW_DEMAND,

KW_DESC,

KW_DESCRIBE,

KW_DIAGNOSE,

KW_DIAGNOSIS,

KW_DISK,

KW_DISTINCT,

KW_DISTINCTPC,

KW_DISTINCTPCSA,

KW_DISTRIBUTED,

KW_DISTRIBUTION,

KW_DIV,

KW_DOUBLE,

KW_DROP,

KW_DROPP,

KW_DUAL,

KW_DUPLICATE,

KW_DYNAMIC,

KW_ELSE,

KW_ENABLE,

KW_ENCRYPTKEY,

KW_ENCRYPTKEYS,

KW_END,

KW_ENGINE,

KW_ENGINES,

KW_ENTER,

KW_ERRORS,

KW_EVENTS,

KW_EXCEPT,

KW_EXCLUDE,

KW_EXISTS,

KW_EXPIRED,

KW_EXPORT,

KW_EXTENDED,

KW_EXTERNAL,

KW_EXTRACT,

KW_FAILED_LOGIN_ATTEMPTS,

KW_FALSE,

KW_FAST,

KW_FEATURE,

KW_FIELDS,

KW_FILE,

KW_FILTER,

KW_FIRST,

KW_FLOAT,

KW_FOLLOWER,

KW_FOLLOWING,

KW_FOR,

KW_FORCE,

KW_FORMAT,

KW_FREE,

KW_FROM,

KW_FRONTEND,

KW_FRONTENDS,

KW_FULL,

KW_FUNCTION,

KW_FUNCTIONS,

KW_GLOBAL,

KW_GRANT,

KW_GRANTS,

KW_GRAPH,

KW_GROUP,

KW_GROUPING,

KW_GROUPS,

KW_HASH,

KW_HAVING,

KW_HDFS,

KW_HELP,

KW_HLL,

KW_HLL_UNION,

KW_HOSTNAME,

KW_HOUR,

KW_HUB,

KW_IDENTIFIED,

KW_IF,

KW_IMMEDIATE,

KW_IN,

KW_INCREMENTAL,

KW_INDEX,

KW_INDEXES,

KW_INFILE,

KW_INNER,

KW_INSERT,

KW_INSTALL,

KW_INT,

KW_INTERMEDIATE,

KW_INTERSECT,

KW_INTERVAL,

KW_INTO,

KW_IS,

KW_ISNULL,

KW_ISOLATION,

KW_INVERTED,

KW_JOB,

KW_JOIN,

KW_JSON,

KW_JSONB,

KW_KEY,

KW_KEYS,

KW_KILL,

KW_LABEL,

KW_LARGEINT,

KW_LAST,

KW_LATERAL,

KW_LDAP,

KW_LDAP_ADMIN_PASSWORD,

KW_LEFT,

KW_LESS,

KW_LEVEL,

KW_LIKE,

KW_LIMIT,

KW_LINK,

KW_LIST,

KW_LOAD,

KW_LOCAL,

KW_LOCATION,

KW_LOCK,

KW_LOW_PRIORITY,

KW_MAP,

KW_MATERIALIZED,

KW_MAX,

KW_MAX_VALUE,

KW_MERGE,

KW_MIGRATE,

KW_MIGRATIONS,

KW_MIN,

KW_MINUS,

KW_MINUTE,

KW_MODIFY,

KW_MONTH,

KW_MATCH,

KW_MATCH_ANY,

KW_MATCH_ALL,

KW_MATCH_PHRASE,

KW_MATCH_PHRASE_PREFIX,

KW_MATCH_REGEXP,

KW_NAME,

KW_NAMES,

KW_NATURAL,

KW_NEGATIVE,

KW_NEVER,

KW_NEXT,

KW_NGRAM_BF,

KW_NO,

KW_NOT,

KW_NULL,

KW_NULLS,

KW_OBSERVER,

KW_OF,

KW_OFFSET,

KW_ON,

KW_ONLY,

KW_OPEN,

KW_OR,

KW_ORDER,

KW_OUTER,

KW_OUTFILE,

KW_OVER,

KW_OVERWRITE,

KW_PARAMETER,

KW_PARTITION,

KW_PARTITIONS,

KW_PASSWORD,

KW_PASSWORD_EXPIRE,

KW_PASSWORD_HISTORY,

KW_PASSWORD_LOCK_TIME,

KW_PASSWORD_REUSE,

KW_PATH,

KW_PAUSE,

KW_PERIOD,

KW_PIPE,

KW_PLUGIN,

KW_PLUGINS,

KW_POLICY,

KW_PRECEDING,

KW_PERCENT,

KW_RECYCLE,

KW_PROC,

KW_PROCEDURE,

KW_PROCESSLIST,

KW_PROFILE,

KW_PROPERTIES,

KW_PROPERTY,

KW_QUANTILE_STATE,

KW_QUANTILE_UNION,

KW_AGG_STATE,

KW_QUERY,

KW_QUOTA,

KW_RANDOM,

KW_RANGE,

KW_RECENT,

KW_READ,

KW_REBALANCE,

KW_RECOVER,

KW_REFRESH,

KW_REGEXP,

KW_RELEASE,

KW_RENAME,

KW_REPAIR,

KW_REPEATABLE,

KW_REPLACE,

KW_REPLACE_IF_NOT_NULL,

KW_REPLICA,

KW_REPOSITORIES,

KW_REPOSITORY,

KW_RESOURCE,

KW_RESOURCES,

KW_RESTORE,

KW_RESUME,

KW_RETURNS,

KW_REVOKE,

KW_RIGHT,

KW_ROLE,

KW_ROLES,

KW_ROLLBACK,

KW_ROLLUP,

KW_ROUTINE,

KW_ROW,

KW_ROWS,

KW_S3,

KW_SAMPLE,

KW_SCHEMA,

KW_SCHEMAS,

KW_SECOND,

KW_SELECT,

KW_SEMI,

KW_SERIALIZABLE,

KW_SESSION,

KW_SET,

KW_SETS,

KW_SHOW,

KW_SIGNED,

KW_SKEW,

KW_SMALLINT,

KW_SNAPSHOT,

KW_SONAME,

KW_SPLIT,

KW_SQL,

KW_SQL_BLOCK_RULE,

KW_START,

KW_STATS,

KW_STATUS,

KW_STOP,

KW_STORAGE,

KW_STREAM,

KW_STRING,

KW_STRUCT,

KW_SUM,

KW_SUPERUSER,

KW_SWITCH,

KW_SYNC,

KW_SYSTEM,

KW_TABLE,

KW_TABLES,

KW_TABLESAMPLE,

KW_TABLET,

KW_TABLETS,

KW_TASK,

KW_TEMPORARY,

KW_TERMINATED,

KW_TEXT,

KW_THAN,

KW_THEN,

KW_TIME,

KW_TIMESTAMP,

KW_TINYINT,

KW_TO,

KW_TRANSACTION,

KW_TRASH,

KW_TRIGGERS,

KW_TRIM,

KW_TRUE,

KW_TRUNCATE,

KW_TYPE,

KW_TYPES,

KW_UNBOUNDED,

KW_UNCOMMITTED,

KW_UNINSTALL,

KW_UNION,

KW_UNIQUE,

KW_UNLOCK,

KW_UNSET,

KW_UNSIGNED,

KW_UPDATE,

KW_USE,

KW_USER,

KW_USING,

KW_VALUE,

KW_VALUES,

KW_VARCHAR,

KW_VARIABLE,

KW_VARIABLES,

KW_VERBOSE,

KW_VERSION,

KW_VIEW,

KW_VIEWS,

KW_WARNINGS,

KW_WEEK,

KW_WHEN,

KW_WHERE,

KW_WHITELIST,

KW_WITH,

KW_WORK,

KW_WORKLOAD,

KW_WRITE,

KW_YEAR,

KW_MTMV,

KW_TYPECAST,

KW_HISTOGRAM,

KW_AUTO,

KW_PREPARE,

KW_EXECUTE,

KW_LINES,

KW_IGNORE,

KW_CONVERT_LSC;

terminal COMMA, COLON, DOT, DOTDOTDOT, AT, STAR, LPAREN, RPAREN, SEMICOLON, LBRACKET, RBRACKET, LBRACE, RBRACE, DIVIDE, MOD, ADD, SUBTRACT, PLACEHOLDER, ARROW;

terminal BITAND, BITOR, BITXOR, BITNOT;

terminal EQUAL, NOT, LESSTHAN, GREATERTHAN, SET_VAR;

terminal COMMENTED_PLAN_HINT_START, COMMENTED_PLAN_HINT_END;

terminal String IDENT;

terminal String NUMERIC_OVERFLOW;

terminal Long INTEGER_LITERAL;

terminal String LARGE_INTEGER_LITERAL;

terminal Double FLOATINGPOINT_LITERAL;

terminal BigDecimal DECIMAL_LITERAL;

terminal String STRING_LITERAL;

terminal String UNMATCHED_STRING_LITERAL;

terminal String COMMENTED_PLAN_HINTS;

// Statement that the result of this parser.

nonterminal List<StatementBase> stmts;

nonterminal StatementBase stmt, show_stmt, show_param, help_stmt, load_stmt,

create_routine_load_stmt, pause_routine_load_stmt, resume_routine_load_stmt, stop_routine_load_stmt,

show_routine_load_stmt, show_routine_load_task_stmt, show_create_routine_load_stmt, show_create_load_stmt, show_create_reporitory_stmt,

describe_stmt, alter_stmt, unset_var_stmt,

use_stmt, kill_stmt, drop_stmt, recover_stmt, grant_stmt, revoke_stmt, create_stmt, set_stmt, sync_stmt, cancel_stmt, cancel_param, delete_stmt,

switch_stmt, transaction_stmt, unsupported_stmt, export_stmt, admin_stmt, truncate_stmt,

import_columns_stmt, import_delete_on_stmt, import_sequence_stmt, import_where_stmt, install_plugin_stmt, uninstall_plugin_stmt,

import_preceding_filter_stmt, unlock_tables_stmt, lock_tables_stmt, refresh_stmt, clean_stmt, analyze_stmt, show_mtmv_stmt, kill_analysis_job_stmt, insert_overwrite_stmt;

nonterminal FromClause opt_using_clause;

nonterminal String transaction_label;

nonterminal ImportColumnDesc import_column_desc;

nonterminal List<ImportColumnDesc> import_column_descs;

// unsupported statement

nonterminal opt_with_consistent_snapshot, opt_work, opt_chain, opt_release;

// Single select statement.

nonterminal SelectStmt select_stmt;

nonterminal ValueList value_clause;

// No return.

nonterminal describe_command, opt_full, opt_inner, opt_outer, from_or_in, keys_or_index, opt_storage, opt_wild_where,

charset, equal, transaction_characteristics, isolation_level,

transaction_access_mode, isolation_types;

// String

nonterminal String user, opt_user, opt_using_charset;

nonterminal UserIdentity user_identity;

nonterminal String quantity;

// Description of user

nonterminal UserDesc grant_user;

// Select or set operation(union/intersect/except) statement.

nonterminal QueryStmt query_stmt;

// Single select_stmt or parenthesized query_stmt.

nonterminal QueryStmt set_operand;

// List of select or set operation(union/intersect/except) blocks connected by set operators or a single select block.

nonterminal List<SetOperand> set_operand_list;

// List of select blocks connected by set operators, with order by or limit.

nonterminal QueryStmt set_operation_with_order_by_or_limit;

nonterminal InsertStmt insert_stmt;

nonterminal InsertTarget insert_target;

nonterminal InsertSource insert_source;

nonterminal UpdateStmt update_stmt;

nonterminal List<BinaryPredicate> set_clause;

nonterminal List<BinaryPredicate> assignment_list;

nonterminal BinaryPredicate assignment;

nonterminal BackupStmt backup_stmt;

nonterminal AbstractBackupTableRefClause opt_backup_table_ref_list;

nonterminal Boolean backup_exclude_or_not;

nonterminal RestoreStmt restore_stmt;

nonterminal PrepareStmt prepare_stmt;

nonterminal ExecuteStmt execute_stmt;

nonterminal SelectList select_clause, select_list, select_sublist;

nonterminal SelectListItem select_list_item, star_expr;

nonterminal Expr expr, non_pred_expr, arithmetic_expr, timestamp_arithmetic_expr, expr_or_default;

nonterminal Expr set_expr_or_default;

nonterminal ArrayList<Expr> expr_list, values, row_value, opt_values, kv_list;

nonterminal ArrayList<LiteralExpr> literal_values, args_list;

nonterminal ArrayList<Expr> func_arg_list;

nonterminal ArrayList<Expr> expr_pipe_list;

nonterminal String select_alias, opt_table_alias, lock_alias, opt_alias;

nonterminal ArrayList<String> ident_list, opt_ident_list;

nonterminal PartitionNames opt_partition_names, partition_names;

nonterminal ArrayList<Long> opt_tablet_list, tablet_list;

nonterminal TableSample opt_table_sample, table_sample;

nonterminal TableSnapshot opt_table_snapshot, table_snapshot;

nonterminal TableName table_name, opt_table_name;

nonterminal FunctionName function_name;

nonterminal EncryptKeyName encryptkey_name;

nonterminal Expr pre_filter_clause;

nonterminal Expr where_clause;

nonterminal Expr delete_on_clause;

nonterminal String sequence_col_clause;

nonterminal Predicate predicate, between_predicate, comparison_predicate,

compound_predicate, in_predicate, like_predicate, exists_predicate, match_predicate;

nonterminal ArrayList<Expr> opt_partition_by_clause;

nonterminal Expr having_clause;

nonterminal ArrayList<OrderByElement> order_by_elements, order_by_clause;

nonterminal OrderByElement order_by_element;

nonterminal Boolean opt_order_param;

nonterminal Boolean opt_nulls_order_param;

nonterminal LimitElement limit_clause;

nonterminal TypeDef type_def, type_def_nullable, opt_intermediate_type;

nonterminal List<TypeDef> type_def_list, type_def_nullable_list;

nonterminal FunctionArgsDef func_args_def;

nonterminal Type type;

nonterminal Expr cast_expr, case_else_clause, analytic_expr;

nonterminal LiteralExpr literal;

nonterminal CaseExpr case_expr;

nonterminal ArrayList<CaseWhenClause> case_when_clause_list;

nonterminal FunctionParams function_params;

nonterminal Expr function_call_expr, array_expr, map_expr;

nonterminal ArrayLiteral array_literal;

nonterminal MapLiteral map_literal;

nonterminal StructField struct_field;

nonterminal ArrayList<StructField> struct_field_list;

nonterminal StructLiteral struct_literal;

nonterminal AnalyticWindow opt_window_clause;

nonterminal AnalyticWindow.Type window_type;

nonterminal AnalyticWindow.Boundary window_boundary;

nonterminal SlotRef column_ref;

nonterminal ArrayList<SlotRef> column_ref_list;

nonterminal FunctionCallExpr column_subscript;

nonterminal FunctionCallExpr column_slice;

nonterminal ArrayList<TableRef> table_ref_list, base_table_ref_list;

nonterminal ArrayList<LateralViewRef> opt_lateral_view_ref_list, lateral_view_ref_list;

nonterminal FromClause from_clause;

nonterminal FromClause opt_from_clause;

nonterminal TableRef table_ref;

nonterminal TableRef base_table_ref;

nonterminal LateralViewRef lateral_view_ref;

nonterminal WithClause opt_with_clause;

nonterminal ArrayList<View> with_view_def_list;

nonterminal View with_view_def;

nonterminal Subquery subquery;

nonterminal TableValuedFunctionRef table_valued_function_ref;

nonterminal InlineViewRef inline_view_ref;

nonterminal JoinOperator join_operator;

nonterminal ArrayList<String> opt_plan_hints;

nonterminal ArrayList<String> opt_sort_hints;

nonterminal Map<String, Map<String, String>> opt_select_hints;

nonterminal Map<String, Map<String, String>> query_hints;

nonterminal Map.Entry<String, Map<String, String>> query_hint;

nonterminal Map<String, String> query_hint_parameters;

nonterminal Map.Entry<String, String> query_hint_parameter;

nonterminal String query_hint_parameter_key;

nonterminal Expr sign_chain_expr;

nonterminal Qualifier opt_set_qualifier;

nonterminal Operation set_op;

nonterminal ArrayList<String> opt_common_hints;

nonterminal String optional_on_ident;

nonterminal LoadTask.MergeType opt_merge_type, opt_with_merge_type;

// Set type

nonterminal SetType option_type, opt_var_type, var_ident_type;

// Set variable

nonterminal SetVar option_value, option_value_follow_option_type, option_value_no_option_type,

user_property;

// List of set variable

nonterminal List<SetVar> option_value_list, option_value_list_continued, start_option_value_list,

start_option_value_list_following_option_type, user_property_list;

nonterminal Map<String, String> key_value_map, opt_key_value_map, opt_key_value_map_in_paren, opt_properties,

opt_ext_properties, opt_enable_feature_properties, properties;

nonterminal ColumnDef column_definition;

nonterminal IndexDef index_definition;

nonterminal IndexDef build_index_definition;

nonterminal ArrayList<ColumnDef> column_definition_list;

nonterminal ArrayList<IndexDef> index_definition_list;

nonterminal AggregateType opt_agg_type;

nonterminal PartitionDesc opt_partition;

nonterminal DistributionDesc opt_distribution;

nonterminal Integer opt_distribution_number;

nonterminal Long opt_field_length;

nonterminal KeysDesc opt_keys;

nonterminal KeysDesc opt_mv_keys;

nonterminal Long opt_id;

nonterminal PartitionKeyDesc partition_key_desc;

nonterminal PartitionKeyDesc list_partition_key_desc;

nonterminal PartitionKeyDesc fixed_partition_key_desc;

nonterminal List<PartitionValue> partition_key_list;

nonterminal List<PartitionValue> partition_value_list;

nonterminal List<PartitionValue> partition_key_item_list;

nonterminal List<List<PartitionValue>> list_partition_values_list;

nonterminal SinglePartitionDesc single_partition_desc;

nonterminal List<AllPartitionDesc> opt_all_partition_desc_list;

nonterminal List<AllPartitionDesc> all_partition_desc_list;

nonterminal PartitionKeyDesc fixed_multi_partition_key_desc;

nonterminal MultiPartitionDesc multi_partition_desc;

nonterminal List<AccessPrivilegeWithCols> privilege_list;

nonterminal List<String> string_list;

nonterminal List<Long> integer_list, job_id_list;

nonterminal AccessPrivilegeWithCols privilege_type;

nonterminal DataDescription data_desc, mysql_data_desc;

nonterminal List<DataDescription> data_desc_list;

nonterminal LabelName job_label;

nonterminal String opt_with_label;

nonterminal BrokerDesc opt_broker;

nonterminal ResourceDesc resource_desc;

nonterminal List<String> opt_col_list, opt_dup_keys, opt_columns_from_path;

nonterminal List<ColWithComment> opt_col_with_comment_list, col_with_comment_list;

nonterminal ColWithComment col_with_comment;

nonterminal List<Expr> opt_col_mapping_list;

nonterminal Separator opt_field_term, opt_line_term, separator;

nonterminal String opt_user_role;

nonterminal TablePattern tbl_pattern;

nonterminal ResourcePattern resource_pattern;

nonterminal WorkloadGroupPattern workload_group_pattern;

nonterminal String ident_or_star;

nonterminal Integer opt_skip_lines;

// password policy

nonterminal PasswordOptions opt_password_option;

nonterminal Integer opt_passwd_history_policy, opt_passwd_reuse_policy;

nonterminal Integer opt_failed_login_attempts, passwd_history_opt, passwd_reuse_opt, opt_lock_account, passwd_time_unit;

nonterminal Long opt_passwd_expire_policy, opt_password_lock_time, passwd_expire_opt, passwd_lock_time_opt;

// Routine load

nonterminal ParseNode load_property;

nonterminal List<ParseNode> opt_load_property_list;

// Boolean

nonterminal Boolean opt_negative, opt_is_allow_null, opt_is_key, opt_read_only, opt_aggregate, opt_local, opt_is_auto_inc;

nonterminal String opt_from_rollup, opt_to_rollup;

nonterminal ColumnPosition opt_col_pos;

// Alter statement

nonterminal AlterClause alter_system_clause, alter_table_clause;

nonterminal List<AlterClause> alter_table_clause_list, opt_rollup, add_rollup_clause_list, drop_rollup_clause_list;

nonterminal AddRollupClause add_rollup_clause;

nonterminal DropRollupClause drop_rollup_clause;

// grouping sets

nonterminal List<ArrayList<Expr>> grouping_set_list;

nonterminal ArrayList<Expr> grouping_set;

nonterminal GroupByClause group_by_clause, grouping_elements;

//

nonterminal String keyword, ident, ident_or_text, variable_name,

charset_name_or_default, old_or_new_charset_name_or_default, opt_collate,

collation_name_or_default, type_func_name_keyword, type_function_name, opt_file_format, opt_file_compress_type,

time_unit, literal_or_ident;

nonterminal PassVar text_or_password;

// sync job

nonterminal List<ChannelDescription> channel_desc_list;

nonterminal ChannelDescription channel_desc;

nonterminal BinlogDesc binlog_desc;

nonterminal ResumeSyncJobStmt resume_sync_job_stmt;

nonterminal PauseSyncJobStmt pause_sync_job_stmt;

nonterminal StopSyncJobStmt stop_sync_job_stmt;

nonterminal JobName job_name;

// analyze

nonterminal Map<String, String> with_analysis_properties;

nonterminal List<Map<String, String>> opt_with_analysis_properties;

nonterminal String opt_db, procedure_or_function, opt_comment, opt_engine;

nonterminal ColumnDef.DefaultValue opt_default_value;

nonterminal Boolean opt_if_exists, opt_if_not_exists;

nonterminal Boolean opt_external;

nonterminal Boolean opt_force;

nonterminal Boolean opt_cached;

nonterminal IndexDef.IndexType opt_index_type;

nonterminal ShowAlterStmt.AlterType opt_alter_type;

nonterminal Boolean opt_builtin;

nonterminal ExplainOptions opt_explain_options;

nonterminal Boolean opt_tmp;

nonterminal OutFileClause opt_outfile;

nonterminal Map<String, String> opt_datasource_properties;

nonterminal Boolean opt_signed_unsigned;

nonterminal StorageBackend storage_backend;

nonterminal ArrayList<LockTable> opt_lock_tables_list;

nonterminal LockTable lock_table;

// mv

nonterminal MVRefreshInfo.BuildMode build_mv;

nonterminal MVRefreshInfo.RefreshMethod opt_refresh_method;

nonterminal MVRefreshTriggerInfo opt_refresh_trigger;

nonterminal MVRefreshInfo opt_mv_refersh_info;

nonterminal PartitionDesc opt_mv_partition;

precedence nonassoc COMMA;

precedence nonassoc STRING_LITERAL;

precedence nonassoc KW_COLUMNS;

precedence nonassoc KW_WITH;

precedence left KW_FULL, KW_MERGE;

precedence left DOT;

precedence left SET_VAR;

precedence left KW_OR;

precedence left KW_AND;

precedence left KW_NOT, NOT;

precedence left KW_BETWEEN, KW_IN, KW_IS, KW_EXISTS;

precedence left KW_LIKE, KW_REGEXP;

precedence left KW_MATCH_ANY, KW_MATCH_ALL, KW_MATCH_PHRASE, KW_MATCH_PHRASE_PREFIX, KW_MATCH_REGEXP, KW_MATCH;

precedence left EQUAL, LESSTHAN, GREATERTHAN;

precedence left ADD, SUBTRACT;

precedence left AT, STAR, DIVIDE, MOD, KW_DIV;

precedence left KW_EXCEPT;

precedence left BITAND, BITOR, BITXOR;

precedence left KW_PIPE;

precedence left BITNOT;

precedence left KW_ORDER, KW_BY, KW_LIMIT;

precedence right KW_PROPERTIES;

precedence left LPAREN, RPAREN;

precedence left KW_PREPARE, KW_EXECUTE;

// Support chaining of timestamp arithmetic exprs.

precedence left KW_INTERVAL;

precedence left KW_OVER;

precedence left KW_COLLATE;

precedence left KW_PARTITION;

precedence left KW_PARTITIONS;

precedence right KW_TEMPORARY;

precedence right LBRACKET;

precedence right LBRACE;

precedence left KW_ENGINE;

// unused

// nonterminal Expr where_clause_without_null, List<String> col_list, opt_charset_name;

start with stmts;

stmts ::=

stmt:stmt

{:

RESULT = Lists.newArrayList(stmt);

:}

| stmts:stmts SEMICOLON stmt:stmt