diff --git a/parser/Dockerfile b/parser/Dockerfile index aca283f15..8b35794ae 100644 --- a/parser/Dockerfile +++ b/parser/Dockerfile @@ -18,8 +18,8 @@ RUN echo "alias antlr='java -jar /antlr-${ANTLR_VERSION}-complete.jar'" >> ~/.ba WORKDIR /workspace -RUN curl -L -o YQLv1Antlr4.g4 https://raw.githubusercontent.com/ydb-platform/ydb/${COMMIT_HASH}/yql/essentials/sql/v1/SQLv1Antlr4.g.in +RUN curl -L -o YQL.g4 https://raw.githubusercontent.com/ydb-platform/ydb/${COMMIT_HASH}/yql/essentials/sql/v1/SQLv1Antlr4.g.in -RUN sed -i "s/grammar SQLv1Antlr4/grammar YQLv1Antlr4/g; s/@GRAMMAR_STRING_CORE_SINGLE@/~('\\\'\' | '\\\\\\\\') | ('\\\\\\\\' .)/g; s/@GRAMMAR_STRING_CORE_DOUBLE@/~('\\\"\' | '\\\\\\\\') | ('\\\\\\\\' .)/g; s/@GRAMMAR_MULTILINE_COMMENT_CORE@/./g" YQLv1Antlr4.g4 +RUN sed -i "s/grammar SQLv1Antlr4/grammar YQL/g; s/@GRAMMAR_STRING_CORE_SINGLE@/~('\\\'\' | '\\\\\\\\') | ('\\\\\\\\' .)/g; s/@GRAMMAR_STRING_CORE_DOUBLE@/~('\\\"\' | '\\\\\\\\') | ('\\\\\\\\' .)/g; s/@GRAMMAR_MULTILINE_COMMENT_CORE@/./g" YQL.g4 CMD ["bash"] \ No newline at end of file diff --git a/parser/Makefile b/parser/Makefile index da2a6144c..64f1b01a2 100644 --- a/parser/Makefile +++ b/parser/Makefile @@ -6,7 +6,7 @@ CURRENT_DIR := $(shell pwd) yql: build-image docker run --rm -v "$(CURRENT_DIR)/yql":/workspace/yql $(IMAGE_NAME) \ - java -jar /antlr-${ANTLR_VERSION}-complete.jar -Dlanguage=Go -package yql -o yql YQLv1Antlr4.g4 + java -jar /antlr-${ANTLR_VERSION}-complete.jar -Dlanguage=Go -package yql -o yql YQL.g4 build-image: docker build -t $(IMAGE_NAME) . diff --git a/parser/go.mod b/parser/go.mod index 7b18a5f2b..2cd516463 100644 --- a/parser/go.mod +++ b/parser/go.mod @@ -1,8 +1,17 @@ -module ydb-go-sdk/parser +module github.com/ydb-platform/ydb-go-sdk/v3/parser -go 1.23.4 +go 1.22 + +toolchain go1.23.0 require ( github.com/antlr4-go/antlr/v4 v4.13.1 + github.com/stretchr/testify v1.10.0 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/parser/go.sum b/parser/go.sum index a4312cda1..015a94033 100644 --- a/parser/go.sum +++ b/parser/go.sum @@ -1,4 +1,14 @@ github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ= github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM= golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/parser/parser_test.go b/parser/parser_test.go new file mode 100644 index 000000000..4dd01cdbf --- /dev/null +++ b/parser/parser_test.go @@ -0,0 +1,59 @@ +package parser + +import ( + "testing" + + "github.com/antlr4-go/antlr/v4" + "github.com/stretchr/testify/require" + + "github.com/ydb-platform/ydb-go-sdk/v3/parser/yql" +) + +type treeShapeListener struct { + *yql.BaseYQLListener + + data []string +} + +func (l *treeShapeListener) EnterEveryRule(ctx antlr.ParserRuleContext) { + l.data = append(l.data, ctx.GetText()) +} + +func TestParserYQL(t *testing.T) { + input := antlr.NewInputStream(`SELECT 1`) + lexer := yql.NewYQLLexer(input) + stream := antlr.NewCommonTokenStream(lexer, 0) + parser := yql.NewYQLParser(stream) + parser.AddErrorListener(antlr.NewDiagnosticErrorListener(true)) + stmt := parser.Select_stmt() + listener := &treeShapeListener{} + antlr.NewParseTreeWalker().Walk(listener, stmt) + require.Equal(t, + []string{ + "SELECT1", + "SELECT1", + "SELECT1", + "SELECT1", + "SELECT1", + "", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "", + }, + listener.data, + ) +} diff --git a/parser/yql/YQLv1Antlr4.interp b/parser/yql/YQL.interp similarity index 100% rename from parser/yql/YQLv1Antlr4.interp rename to parser/yql/YQL.interp diff --git a/parser/yql/YQLv1Antlr4.tokens b/parser/yql/YQL.tokens similarity index 100% rename from parser/yql/YQLv1Antlr4.tokens rename to parser/yql/YQL.tokens diff --git a/parser/yql/YQLv1Antlr4Lexer.interp b/parser/yql/YQLLexer.interp similarity index 100% rename from parser/yql/YQLv1Antlr4Lexer.interp rename to parser/yql/YQLLexer.interp diff --git a/parser/yql/YQLv1Antlr4Lexer.tokens b/parser/yql/YQLLexer.tokens similarity index 100% rename from parser/yql/YQLv1Antlr4Lexer.tokens rename to parser/yql/YQLLexer.tokens diff --git a/parser/yql/yql_base_listener.go b/parser/yql/yql_base_listener.go new file mode 100644 index 000000000..f55a9dcdf --- /dev/null +++ b/parser/yql/yql_base_listener.go @@ -0,0 +1,2619 @@ +// Code generated from YQL.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package yql // YQL +import "github.com/antlr4-go/antlr/v4" + +// BaseYQLListener is a complete listener for a parse tree produced by YQLParser. +type BaseYQLListener struct{} + +var _ YQLListener = &BaseYQLListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseYQLListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseYQLListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseYQLListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseYQLListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterSql_query is called when production sql_query is entered. +func (s *BaseYQLListener) EnterSql_query(ctx *Sql_queryContext) {} + +// ExitSql_query is called when production sql_query is exited. +func (s *BaseYQLListener) ExitSql_query(ctx *Sql_queryContext) {} + +// EnterSql_stmt_list is called when production sql_stmt_list is entered. +func (s *BaseYQLListener) EnterSql_stmt_list(ctx *Sql_stmt_listContext) {} + +// ExitSql_stmt_list is called when production sql_stmt_list is exited. +func (s *BaseYQLListener) ExitSql_stmt_list(ctx *Sql_stmt_listContext) {} + +// EnterAnsi_sql_stmt_list is called when production ansi_sql_stmt_list is entered. +func (s *BaseYQLListener) EnterAnsi_sql_stmt_list(ctx *Ansi_sql_stmt_listContext) {} + +// ExitAnsi_sql_stmt_list is called when production ansi_sql_stmt_list is exited. +func (s *BaseYQLListener) ExitAnsi_sql_stmt_list(ctx *Ansi_sql_stmt_listContext) {} + +// EnterLambda_body is called when production lambda_body is entered. +func (s *BaseYQLListener) EnterLambda_body(ctx *Lambda_bodyContext) {} + +// ExitLambda_body is called when production lambda_body is exited. +func (s *BaseYQLListener) ExitLambda_body(ctx *Lambda_bodyContext) {} + +// EnterLambda_stmt is called when production lambda_stmt is entered. +func (s *BaseYQLListener) EnterLambda_stmt(ctx *Lambda_stmtContext) {} + +// ExitLambda_stmt is called when production lambda_stmt is exited. +func (s *BaseYQLListener) ExitLambda_stmt(ctx *Lambda_stmtContext) {} + +// EnterSql_stmt is called when production sql_stmt is entered. +func (s *BaseYQLListener) EnterSql_stmt(ctx *Sql_stmtContext) {} + +// ExitSql_stmt is called when production sql_stmt is exited. +func (s *BaseYQLListener) ExitSql_stmt(ctx *Sql_stmtContext) {} + +// EnterSql_stmt_core is called when production sql_stmt_core is entered. +func (s *BaseYQLListener) EnterSql_stmt_core(ctx *Sql_stmt_coreContext) {} + +// ExitSql_stmt_core is called when production sql_stmt_core is exited. +func (s *BaseYQLListener) ExitSql_stmt_core(ctx *Sql_stmt_coreContext) {} + +// EnterExpr is called when production expr is entered. +func (s *BaseYQLListener) EnterExpr(ctx *ExprContext) {} + +// ExitExpr is called when production expr is exited. +func (s *BaseYQLListener) ExitExpr(ctx *ExprContext) {} + +// EnterOr_subexpr is called when production or_subexpr is entered. +func (s *BaseYQLListener) EnterOr_subexpr(ctx *Or_subexprContext) {} + +// ExitOr_subexpr is called when production or_subexpr is exited. +func (s *BaseYQLListener) ExitOr_subexpr(ctx *Or_subexprContext) {} + +// EnterAnd_subexpr is called when production and_subexpr is entered. +func (s *BaseYQLListener) EnterAnd_subexpr(ctx *And_subexprContext) {} + +// ExitAnd_subexpr is called when production and_subexpr is exited. +func (s *BaseYQLListener) ExitAnd_subexpr(ctx *And_subexprContext) {} + +// EnterXor_subexpr is called when production xor_subexpr is entered. +func (s *BaseYQLListener) EnterXor_subexpr(ctx *Xor_subexprContext) {} + +// ExitXor_subexpr is called when production xor_subexpr is exited. +func (s *BaseYQLListener) ExitXor_subexpr(ctx *Xor_subexprContext) {} + +// EnterDistinct_from_op is called when production distinct_from_op is entered. +func (s *BaseYQLListener) EnterDistinct_from_op(ctx *Distinct_from_opContext) {} + +// ExitDistinct_from_op is called when production distinct_from_op is exited. +func (s *BaseYQLListener) ExitDistinct_from_op(ctx *Distinct_from_opContext) {} + +// EnterCond_expr is called when production cond_expr is entered. +func (s *BaseYQLListener) EnterCond_expr(ctx *Cond_exprContext) {} + +// ExitCond_expr is called when production cond_expr is exited. +func (s *BaseYQLListener) ExitCond_expr(ctx *Cond_exprContext) {} + +// EnterMatch_op is called when production match_op is entered. +func (s *BaseYQLListener) EnterMatch_op(ctx *Match_opContext) {} + +// ExitMatch_op is called when production match_op is exited. +func (s *BaseYQLListener) ExitMatch_op(ctx *Match_opContext) {} + +// EnterEq_subexpr is called when production eq_subexpr is entered. +func (s *BaseYQLListener) EnterEq_subexpr(ctx *Eq_subexprContext) {} + +// ExitEq_subexpr is called when production eq_subexpr is exited. +func (s *BaseYQLListener) ExitEq_subexpr(ctx *Eq_subexprContext) {} + +// EnterShift_right is called when production shift_right is entered. +func (s *BaseYQLListener) EnterShift_right(ctx *Shift_rightContext) {} + +// ExitShift_right is called when production shift_right is exited. +func (s *BaseYQLListener) ExitShift_right(ctx *Shift_rightContext) {} + +// EnterRot_right is called when production rot_right is entered. +func (s *BaseYQLListener) EnterRot_right(ctx *Rot_rightContext) {} + +// ExitRot_right is called when production rot_right is exited. +func (s *BaseYQLListener) ExitRot_right(ctx *Rot_rightContext) {} + +// EnterDouble_question is called when production double_question is entered. +func (s *BaseYQLListener) EnterDouble_question(ctx *Double_questionContext) {} + +// ExitDouble_question is called when production double_question is exited. +func (s *BaseYQLListener) ExitDouble_question(ctx *Double_questionContext) {} + +// EnterNeq_subexpr is called when production neq_subexpr is entered. +func (s *BaseYQLListener) EnterNeq_subexpr(ctx *Neq_subexprContext) {} + +// ExitNeq_subexpr is called when production neq_subexpr is exited. +func (s *BaseYQLListener) ExitNeq_subexpr(ctx *Neq_subexprContext) {} + +// EnterBit_subexpr is called when production bit_subexpr is entered. +func (s *BaseYQLListener) EnterBit_subexpr(ctx *Bit_subexprContext) {} + +// ExitBit_subexpr is called when production bit_subexpr is exited. +func (s *BaseYQLListener) ExitBit_subexpr(ctx *Bit_subexprContext) {} + +// EnterAdd_subexpr is called when production add_subexpr is entered. +func (s *BaseYQLListener) EnterAdd_subexpr(ctx *Add_subexprContext) {} + +// ExitAdd_subexpr is called when production add_subexpr is exited. +func (s *BaseYQLListener) ExitAdd_subexpr(ctx *Add_subexprContext) {} + +// EnterMul_subexpr is called when production mul_subexpr is entered. +func (s *BaseYQLListener) EnterMul_subexpr(ctx *Mul_subexprContext) {} + +// ExitMul_subexpr is called when production mul_subexpr is exited. +func (s *BaseYQLListener) ExitMul_subexpr(ctx *Mul_subexprContext) {} + +// EnterCon_subexpr is called when production con_subexpr is entered. +func (s *BaseYQLListener) EnterCon_subexpr(ctx *Con_subexprContext) {} + +// ExitCon_subexpr is called when production con_subexpr is exited. +func (s *BaseYQLListener) ExitCon_subexpr(ctx *Con_subexprContext) {} + +// EnterUnary_op is called when production unary_op is entered. +func (s *BaseYQLListener) EnterUnary_op(ctx *Unary_opContext) {} + +// ExitUnary_op is called when production unary_op is exited. +func (s *BaseYQLListener) ExitUnary_op(ctx *Unary_opContext) {} + +// EnterUnary_subexpr_suffix is called when production unary_subexpr_suffix is entered. +func (s *BaseYQLListener) EnterUnary_subexpr_suffix(ctx *Unary_subexpr_suffixContext) {} + +// ExitUnary_subexpr_suffix is called when production unary_subexpr_suffix is exited. +func (s *BaseYQLListener) ExitUnary_subexpr_suffix(ctx *Unary_subexpr_suffixContext) {} + +// EnterUnary_casual_subexpr is called when production unary_casual_subexpr is entered. +func (s *BaseYQLListener) EnterUnary_casual_subexpr(ctx *Unary_casual_subexprContext) {} + +// ExitUnary_casual_subexpr is called when production unary_casual_subexpr is exited. +func (s *BaseYQLListener) ExitUnary_casual_subexpr(ctx *Unary_casual_subexprContext) {} + +// EnterIn_unary_casual_subexpr is called when production in_unary_casual_subexpr is entered. +func (s *BaseYQLListener) EnterIn_unary_casual_subexpr(ctx *In_unary_casual_subexprContext) {} + +// ExitIn_unary_casual_subexpr is called when production in_unary_casual_subexpr is exited. +func (s *BaseYQLListener) ExitIn_unary_casual_subexpr(ctx *In_unary_casual_subexprContext) {} + +// EnterUnary_subexpr is called when production unary_subexpr is entered. +func (s *BaseYQLListener) EnterUnary_subexpr(ctx *Unary_subexprContext) {} + +// ExitUnary_subexpr is called when production unary_subexpr is exited. +func (s *BaseYQLListener) ExitUnary_subexpr(ctx *Unary_subexprContext) {} + +// EnterIn_unary_subexpr is called when production in_unary_subexpr is entered. +func (s *BaseYQLListener) EnterIn_unary_subexpr(ctx *In_unary_subexprContext) {} + +// ExitIn_unary_subexpr is called when production in_unary_subexpr is exited. +func (s *BaseYQLListener) ExitIn_unary_subexpr(ctx *In_unary_subexprContext) {} + +// EnterList_literal is called when production list_literal is entered. +func (s *BaseYQLListener) EnterList_literal(ctx *List_literalContext) {} + +// ExitList_literal is called when production list_literal is exited. +func (s *BaseYQLListener) ExitList_literal(ctx *List_literalContext) {} + +// EnterExpr_dict_list is called when production expr_dict_list is entered. +func (s *BaseYQLListener) EnterExpr_dict_list(ctx *Expr_dict_listContext) {} + +// ExitExpr_dict_list is called when production expr_dict_list is exited. +func (s *BaseYQLListener) ExitExpr_dict_list(ctx *Expr_dict_listContext) {} + +// EnterDict_literal is called when production dict_literal is entered. +func (s *BaseYQLListener) EnterDict_literal(ctx *Dict_literalContext) {} + +// ExitDict_literal is called when production dict_literal is exited. +func (s *BaseYQLListener) ExitDict_literal(ctx *Dict_literalContext) {} + +// EnterExpr_struct_list is called when production expr_struct_list is entered. +func (s *BaseYQLListener) EnterExpr_struct_list(ctx *Expr_struct_listContext) {} + +// ExitExpr_struct_list is called when production expr_struct_list is exited. +func (s *BaseYQLListener) ExitExpr_struct_list(ctx *Expr_struct_listContext) {} + +// EnterStruct_literal is called when production struct_literal is entered. +func (s *BaseYQLListener) EnterStruct_literal(ctx *Struct_literalContext) {} + +// ExitStruct_literal is called when production struct_literal is exited. +func (s *BaseYQLListener) ExitStruct_literal(ctx *Struct_literalContext) {} + +// EnterAtom_expr is called when production atom_expr is entered. +func (s *BaseYQLListener) EnterAtom_expr(ctx *Atom_exprContext) {} + +// ExitAtom_expr is called when production atom_expr is exited. +func (s *BaseYQLListener) ExitAtom_expr(ctx *Atom_exprContext) {} + +// EnterIn_atom_expr is called when production in_atom_expr is entered. +func (s *BaseYQLListener) EnterIn_atom_expr(ctx *In_atom_exprContext) {} + +// ExitIn_atom_expr is called when production in_atom_expr is exited. +func (s *BaseYQLListener) ExitIn_atom_expr(ctx *In_atom_exprContext) {} + +// EnterCast_expr is called when production cast_expr is entered. +func (s *BaseYQLListener) EnterCast_expr(ctx *Cast_exprContext) {} + +// ExitCast_expr is called when production cast_expr is exited. +func (s *BaseYQLListener) ExitCast_expr(ctx *Cast_exprContext) {} + +// EnterBitcast_expr is called when production bitcast_expr is entered. +func (s *BaseYQLListener) EnterBitcast_expr(ctx *Bitcast_exprContext) {} + +// ExitBitcast_expr is called when production bitcast_expr is exited. +func (s *BaseYQLListener) ExitBitcast_expr(ctx *Bitcast_exprContext) {} + +// EnterExists_expr is called when production exists_expr is entered. +func (s *BaseYQLListener) EnterExists_expr(ctx *Exists_exprContext) {} + +// ExitExists_expr is called when production exists_expr is exited. +func (s *BaseYQLListener) ExitExists_expr(ctx *Exists_exprContext) {} + +// EnterCase_expr is called when production case_expr is entered. +func (s *BaseYQLListener) EnterCase_expr(ctx *Case_exprContext) {} + +// ExitCase_expr is called when production case_expr is exited. +func (s *BaseYQLListener) ExitCase_expr(ctx *Case_exprContext) {} + +// EnterLambda is called when production lambda is entered. +func (s *BaseYQLListener) EnterLambda(ctx *LambdaContext) {} + +// ExitLambda is called when production lambda is exited. +func (s *BaseYQLListener) ExitLambda(ctx *LambdaContext) {} + +// EnterIn_expr is called when production in_expr is entered. +func (s *BaseYQLListener) EnterIn_expr(ctx *In_exprContext) {} + +// ExitIn_expr is called when production in_expr is exited. +func (s *BaseYQLListener) ExitIn_expr(ctx *In_exprContext) {} + +// EnterJson_api_expr is called when production json_api_expr is entered. +func (s *BaseYQLListener) EnterJson_api_expr(ctx *Json_api_exprContext) {} + +// ExitJson_api_expr is called when production json_api_expr is exited. +func (s *BaseYQLListener) ExitJson_api_expr(ctx *Json_api_exprContext) {} + +// EnterJsonpath_spec is called when production jsonpath_spec is entered. +func (s *BaseYQLListener) EnterJsonpath_spec(ctx *Jsonpath_specContext) {} + +// ExitJsonpath_spec is called when production jsonpath_spec is exited. +func (s *BaseYQLListener) ExitJsonpath_spec(ctx *Jsonpath_specContext) {} + +// EnterJson_variable_name is called when production json_variable_name is entered. +func (s *BaseYQLListener) EnterJson_variable_name(ctx *Json_variable_nameContext) {} + +// ExitJson_variable_name is called when production json_variable_name is exited. +func (s *BaseYQLListener) ExitJson_variable_name(ctx *Json_variable_nameContext) {} + +// EnterJson_variable is called when production json_variable is entered. +func (s *BaseYQLListener) EnterJson_variable(ctx *Json_variableContext) {} + +// ExitJson_variable is called when production json_variable is exited. +func (s *BaseYQLListener) ExitJson_variable(ctx *Json_variableContext) {} + +// EnterJson_variables is called when production json_variables is entered. +func (s *BaseYQLListener) EnterJson_variables(ctx *Json_variablesContext) {} + +// ExitJson_variables is called when production json_variables is exited. +func (s *BaseYQLListener) ExitJson_variables(ctx *Json_variablesContext) {} + +// EnterJson_common_args is called when production json_common_args is entered. +func (s *BaseYQLListener) EnterJson_common_args(ctx *Json_common_argsContext) {} + +// ExitJson_common_args is called when production json_common_args is exited. +func (s *BaseYQLListener) ExitJson_common_args(ctx *Json_common_argsContext) {} + +// EnterJson_case_handler is called when production json_case_handler is entered. +func (s *BaseYQLListener) EnterJson_case_handler(ctx *Json_case_handlerContext) {} + +// ExitJson_case_handler is called when production json_case_handler is exited. +func (s *BaseYQLListener) ExitJson_case_handler(ctx *Json_case_handlerContext) {} + +// EnterJson_value is called when production json_value is entered. +func (s *BaseYQLListener) EnterJson_value(ctx *Json_valueContext) {} + +// ExitJson_value is called when production json_value is exited. +func (s *BaseYQLListener) ExitJson_value(ctx *Json_valueContext) {} + +// EnterJson_exists_handler is called when production json_exists_handler is entered. +func (s *BaseYQLListener) EnterJson_exists_handler(ctx *Json_exists_handlerContext) {} + +// ExitJson_exists_handler is called when production json_exists_handler is exited. +func (s *BaseYQLListener) ExitJson_exists_handler(ctx *Json_exists_handlerContext) {} + +// EnterJson_exists is called when production json_exists is entered. +func (s *BaseYQLListener) EnterJson_exists(ctx *Json_existsContext) {} + +// ExitJson_exists is called when production json_exists is exited. +func (s *BaseYQLListener) ExitJson_exists(ctx *Json_existsContext) {} + +// EnterJson_query_wrapper is called when production json_query_wrapper is entered. +func (s *BaseYQLListener) EnterJson_query_wrapper(ctx *Json_query_wrapperContext) {} + +// ExitJson_query_wrapper is called when production json_query_wrapper is exited. +func (s *BaseYQLListener) ExitJson_query_wrapper(ctx *Json_query_wrapperContext) {} + +// EnterJson_query_handler is called when production json_query_handler is entered. +func (s *BaseYQLListener) EnterJson_query_handler(ctx *Json_query_handlerContext) {} + +// ExitJson_query_handler is called when production json_query_handler is exited. +func (s *BaseYQLListener) ExitJson_query_handler(ctx *Json_query_handlerContext) {} + +// EnterJson_query is called when production json_query is entered. +func (s *BaseYQLListener) EnterJson_query(ctx *Json_queryContext) {} + +// ExitJson_query is called when production json_query is exited. +func (s *BaseYQLListener) ExitJson_query(ctx *Json_queryContext) {} + +// EnterSmart_parenthesis is called when production smart_parenthesis is entered. +func (s *BaseYQLListener) EnterSmart_parenthesis(ctx *Smart_parenthesisContext) {} + +// ExitSmart_parenthesis is called when production smart_parenthesis is exited. +func (s *BaseYQLListener) ExitSmart_parenthesis(ctx *Smart_parenthesisContext) {} + +// EnterExpr_list is called when production expr_list is entered. +func (s *BaseYQLListener) EnterExpr_list(ctx *Expr_listContext) {} + +// ExitExpr_list is called when production expr_list is exited. +func (s *BaseYQLListener) ExitExpr_list(ctx *Expr_listContext) {} + +// EnterPure_column_list is called when production pure_column_list is entered. +func (s *BaseYQLListener) EnterPure_column_list(ctx *Pure_column_listContext) {} + +// ExitPure_column_list is called when production pure_column_list is exited. +func (s *BaseYQLListener) ExitPure_column_list(ctx *Pure_column_listContext) {} + +// EnterPure_column_or_named is called when production pure_column_or_named is entered. +func (s *BaseYQLListener) EnterPure_column_or_named(ctx *Pure_column_or_namedContext) {} + +// ExitPure_column_or_named is called when production pure_column_or_named is exited. +func (s *BaseYQLListener) ExitPure_column_or_named(ctx *Pure_column_or_namedContext) {} + +// EnterPure_column_or_named_list is called when production pure_column_or_named_list is entered. +func (s *BaseYQLListener) EnterPure_column_or_named_list(ctx *Pure_column_or_named_listContext) {} + +// ExitPure_column_or_named_list is called when production pure_column_or_named_list is exited. +func (s *BaseYQLListener) ExitPure_column_or_named_list(ctx *Pure_column_or_named_listContext) {} + +// EnterColumn_name is called when production column_name is entered. +func (s *BaseYQLListener) EnterColumn_name(ctx *Column_nameContext) {} + +// ExitColumn_name is called when production column_name is exited. +func (s *BaseYQLListener) ExitColumn_name(ctx *Column_nameContext) {} + +// EnterWithout_column_name is called when production without_column_name is entered. +func (s *BaseYQLListener) EnterWithout_column_name(ctx *Without_column_nameContext) {} + +// ExitWithout_column_name is called when production without_column_name is exited. +func (s *BaseYQLListener) ExitWithout_column_name(ctx *Without_column_nameContext) {} + +// EnterColumn_list is called when production column_list is entered. +func (s *BaseYQLListener) EnterColumn_list(ctx *Column_listContext) {} + +// ExitColumn_list is called when production column_list is exited. +func (s *BaseYQLListener) ExitColumn_list(ctx *Column_listContext) {} + +// EnterWithout_column_list is called when production without_column_list is entered. +func (s *BaseYQLListener) EnterWithout_column_list(ctx *Without_column_listContext) {} + +// ExitWithout_column_list is called when production without_column_list is exited. +func (s *BaseYQLListener) ExitWithout_column_list(ctx *Without_column_listContext) {} + +// EnterNamed_expr is called when production named_expr is entered. +func (s *BaseYQLListener) EnterNamed_expr(ctx *Named_exprContext) {} + +// ExitNamed_expr is called when production named_expr is exited. +func (s *BaseYQLListener) ExitNamed_expr(ctx *Named_exprContext) {} + +// EnterNamed_expr_list is called when production named_expr_list is entered. +func (s *BaseYQLListener) EnterNamed_expr_list(ctx *Named_expr_listContext) {} + +// ExitNamed_expr_list is called when production named_expr_list is exited. +func (s *BaseYQLListener) ExitNamed_expr_list(ctx *Named_expr_listContext) {} + +// EnterInvoke_expr is called when production invoke_expr is entered. +func (s *BaseYQLListener) EnterInvoke_expr(ctx *Invoke_exprContext) {} + +// ExitInvoke_expr is called when production invoke_expr is exited. +func (s *BaseYQLListener) ExitInvoke_expr(ctx *Invoke_exprContext) {} + +// EnterInvoke_expr_tail is called when production invoke_expr_tail is entered. +func (s *BaseYQLListener) EnterInvoke_expr_tail(ctx *Invoke_expr_tailContext) {} + +// ExitInvoke_expr_tail is called when production invoke_expr_tail is exited. +func (s *BaseYQLListener) ExitInvoke_expr_tail(ctx *Invoke_expr_tailContext) {} + +// EnterUsing_call_expr is called when production using_call_expr is entered. +func (s *BaseYQLListener) EnterUsing_call_expr(ctx *Using_call_exprContext) {} + +// ExitUsing_call_expr is called when production using_call_expr is exited. +func (s *BaseYQLListener) ExitUsing_call_expr(ctx *Using_call_exprContext) {} + +// EnterKey_expr is called when production key_expr is entered. +func (s *BaseYQLListener) EnterKey_expr(ctx *Key_exprContext) {} + +// ExitKey_expr is called when production key_expr is exited. +func (s *BaseYQLListener) ExitKey_expr(ctx *Key_exprContext) {} + +// EnterWhen_expr is called when production when_expr is entered. +func (s *BaseYQLListener) EnterWhen_expr(ctx *When_exprContext) {} + +// ExitWhen_expr is called when production when_expr is exited. +func (s *BaseYQLListener) ExitWhen_expr(ctx *When_exprContext) {} + +// EnterLiteral_value is called when production literal_value is entered. +func (s *BaseYQLListener) EnterLiteral_value(ctx *Literal_valueContext) {} + +// ExitLiteral_value is called when production literal_value is exited. +func (s *BaseYQLListener) ExitLiteral_value(ctx *Literal_valueContext) {} + +// EnterBind_parameter is called when production bind_parameter is entered. +func (s *BaseYQLListener) EnterBind_parameter(ctx *Bind_parameterContext) {} + +// ExitBind_parameter is called when production bind_parameter is exited. +func (s *BaseYQLListener) ExitBind_parameter(ctx *Bind_parameterContext) {} + +// EnterOpt_bind_parameter is called when production opt_bind_parameter is entered. +func (s *BaseYQLListener) EnterOpt_bind_parameter(ctx *Opt_bind_parameterContext) {} + +// ExitOpt_bind_parameter is called when production opt_bind_parameter is exited. +func (s *BaseYQLListener) ExitOpt_bind_parameter(ctx *Opt_bind_parameterContext) {} + +// EnterBind_parameter_list is called when production bind_parameter_list is entered. +func (s *BaseYQLListener) EnterBind_parameter_list(ctx *Bind_parameter_listContext) {} + +// ExitBind_parameter_list is called when production bind_parameter_list is exited. +func (s *BaseYQLListener) ExitBind_parameter_list(ctx *Bind_parameter_listContext) {} + +// EnterNamed_bind_parameter is called when production named_bind_parameter is entered. +func (s *BaseYQLListener) EnterNamed_bind_parameter(ctx *Named_bind_parameterContext) {} + +// ExitNamed_bind_parameter is called when production named_bind_parameter is exited. +func (s *BaseYQLListener) ExitNamed_bind_parameter(ctx *Named_bind_parameterContext) {} + +// EnterNamed_bind_parameter_list is called when production named_bind_parameter_list is entered. +func (s *BaseYQLListener) EnterNamed_bind_parameter_list(ctx *Named_bind_parameter_listContext) {} + +// ExitNamed_bind_parameter_list is called when production named_bind_parameter_list is exited. +func (s *BaseYQLListener) ExitNamed_bind_parameter_list(ctx *Named_bind_parameter_listContext) {} + +// EnterSigned_number is called when production signed_number is entered. +func (s *BaseYQLListener) EnterSigned_number(ctx *Signed_numberContext) {} + +// ExitSigned_number is called when production signed_number is exited. +func (s *BaseYQLListener) ExitSigned_number(ctx *Signed_numberContext) {} + +// EnterType_name_simple is called when production type_name_simple is entered. +func (s *BaseYQLListener) EnterType_name_simple(ctx *Type_name_simpleContext) {} + +// ExitType_name_simple is called when production type_name_simple is exited. +func (s *BaseYQLListener) ExitType_name_simple(ctx *Type_name_simpleContext) {} + +// EnterInteger_or_bind is called when production integer_or_bind is entered. +func (s *BaseYQLListener) EnterInteger_or_bind(ctx *Integer_or_bindContext) {} + +// ExitInteger_or_bind is called when production integer_or_bind is exited. +func (s *BaseYQLListener) ExitInteger_or_bind(ctx *Integer_or_bindContext) {} + +// EnterType_name_tag is called when production type_name_tag is entered. +func (s *BaseYQLListener) EnterType_name_tag(ctx *Type_name_tagContext) {} + +// ExitType_name_tag is called when production type_name_tag is exited. +func (s *BaseYQLListener) ExitType_name_tag(ctx *Type_name_tagContext) {} + +// EnterStruct_arg is called when production struct_arg is entered. +func (s *BaseYQLListener) EnterStruct_arg(ctx *Struct_argContext) {} + +// ExitStruct_arg is called when production struct_arg is exited. +func (s *BaseYQLListener) ExitStruct_arg(ctx *Struct_argContext) {} + +// EnterStruct_arg_positional is called when production struct_arg_positional is entered. +func (s *BaseYQLListener) EnterStruct_arg_positional(ctx *Struct_arg_positionalContext) {} + +// ExitStruct_arg_positional is called when production struct_arg_positional is exited. +func (s *BaseYQLListener) ExitStruct_arg_positional(ctx *Struct_arg_positionalContext) {} + +// EnterVariant_arg is called when production variant_arg is entered. +func (s *BaseYQLListener) EnterVariant_arg(ctx *Variant_argContext) {} + +// ExitVariant_arg is called when production variant_arg is exited. +func (s *BaseYQLListener) ExitVariant_arg(ctx *Variant_argContext) {} + +// EnterCallable_arg is called when production callable_arg is entered. +func (s *BaseYQLListener) EnterCallable_arg(ctx *Callable_argContext) {} + +// ExitCallable_arg is called when production callable_arg is exited. +func (s *BaseYQLListener) ExitCallable_arg(ctx *Callable_argContext) {} + +// EnterCallable_arg_list is called when production callable_arg_list is entered. +func (s *BaseYQLListener) EnterCallable_arg_list(ctx *Callable_arg_listContext) {} + +// ExitCallable_arg_list is called when production callable_arg_list is exited. +func (s *BaseYQLListener) ExitCallable_arg_list(ctx *Callable_arg_listContext) {} + +// EnterType_name_decimal is called when production type_name_decimal is entered. +func (s *BaseYQLListener) EnterType_name_decimal(ctx *Type_name_decimalContext) {} + +// ExitType_name_decimal is called when production type_name_decimal is exited. +func (s *BaseYQLListener) ExitType_name_decimal(ctx *Type_name_decimalContext) {} + +// EnterType_name_optional is called when production type_name_optional is entered. +func (s *BaseYQLListener) EnterType_name_optional(ctx *Type_name_optionalContext) {} + +// ExitType_name_optional is called when production type_name_optional is exited. +func (s *BaseYQLListener) ExitType_name_optional(ctx *Type_name_optionalContext) {} + +// EnterType_name_tuple is called when production type_name_tuple is entered. +func (s *BaseYQLListener) EnterType_name_tuple(ctx *Type_name_tupleContext) {} + +// ExitType_name_tuple is called when production type_name_tuple is exited. +func (s *BaseYQLListener) ExitType_name_tuple(ctx *Type_name_tupleContext) {} + +// EnterType_name_struct is called when production type_name_struct is entered. +func (s *BaseYQLListener) EnterType_name_struct(ctx *Type_name_structContext) {} + +// ExitType_name_struct is called when production type_name_struct is exited. +func (s *BaseYQLListener) ExitType_name_struct(ctx *Type_name_structContext) {} + +// EnterType_name_variant is called when production type_name_variant is entered. +func (s *BaseYQLListener) EnterType_name_variant(ctx *Type_name_variantContext) {} + +// ExitType_name_variant is called when production type_name_variant is exited. +func (s *BaseYQLListener) ExitType_name_variant(ctx *Type_name_variantContext) {} + +// EnterType_name_list is called when production type_name_list is entered. +func (s *BaseYQLListener) EnterType_name_list(ctx *Type_name_listContext) {} + +// ExitType_name_list is called when production type_name_list is exited. +func (s *BaseYQLListener) ExitType_name_list(ctx *Type_name_listContext) {} + +// EnterType_name_stream is called when production type_name_stream is entered. +func (s *BaseYQLListener) EnterType_name_stream(ctx *Type_name_streamContext) {} + +// ExitType_name_stream is called when production type_name_stream is exited. +func (s *BaseYQLListener) ExitType_name_stream(ctx *Type_name_streamContext) {} + +// EnterType_name_flow is called when production type_name_flow is entered. +func (s *BaseYQLListener) EnterType_name_flow(ctx *Type_name_flowContext) {} + +// ExitType_name_flow is called when production type_name_flow is exited. +func (s *BaseYQLListener) ExitType_name_flow(ctx *Type_name_flowContext) {} + +// EnterType_name_dict is called when production type_name_dict is entered. +func (s *BaseYQLListener) EnterType_name_dict(ctx *Type_name_dictContext) {} + +// ExitType_name_dict is called when production type_name_dict is exited. +func (s *BaseYQLListener) ExitType_name_dict(ctx *Type_name_dictContext) {} + +// EnterType_name_set is called when production type_name_set is entered. +func (s *BaseYQLListener) EnterType_name_set(ctx *Type_name_setContext) {} + +// ExitType_name_set is called when production type_name_set is exited. +func (s *BaseYQLListener) ExitType_name_set(ctx *Type_name_setContext) {} + +// EnterType_name_enum is called when production type_name_enum is entered. +func (s *BaseYQLListener) EnterType_name_enum(ctx *Type_name_enumContext) {} + +// ExitType_name_enum is called when production type_name_enum is exited. +func (s *BaseYQLListener) ExitType_name_enum(ctx *Type_name_enumContext) {} + +// EnterType_name_resource is called when production type_name_resource is entered. +func (s *BaseYQLListener) EnterType_name_resource(ctx *Type_name_resourceContext) {} + +// ExitType_name_resource is called when production type_name_resource is exited. +func (s *BaseYQLListener) ExitType_name_resource(ctx *Type_name_resourceContext) {} + +// EnterType_name_tagged is called when production type_name_tagged is entered. +func (s *BaseYQLListener) EnterType_name_tagged(ctx *Type_name_taggedContext) {} + +// ExitType_name_tagged is called when production type_name_tagged is exited. +func (s *BaseYQLListener) ExitType_name_tagged(ctx *Type_name_taggedContext) {} + +// EnterType_name_callable is called when production type_name_callable is entered. +func (s *BaseYQLListener) EnterType_name_callable(ctx *Type_name_callableContext) {} + +// ExitType_name_callable is called when production type_name_callable is exited. +func (s *BaseYQLListener) ExitType_name_callable(ctx *Type_name_callableContext) {} + +// EnterType_name_composite is called when production type_name_composite is entered. +func (s *BaseYQLListener) EnterType_name_composite(ctx *Type_name_compositeContext) {} + +// ExitType_name_composite is called when production type_name_composite is exited. +func (s *BaseYQLListener) ExitType_name_composite(ctx *Type_name_compositeContext) {} + +// EnterType_name is called when production type_name is entered. +func (s *BaseYQLListener) EnterType_name(ctx *Type_nameContext) {} + +// ExitType_name is called when production type_name is exited. +func (s *BaseYQLListener) ExitType_name(ctx *Type_nameContext) {} + +// EnterType_name_or_bind is called when production type_name_or_bind is entered. +func (s *BaseYQLListener) EnterType_name_or_bind(ctx *Type_name_or_bindContext) {} + +// ExitType_name_or_bind is called when production type_name_or_bind is exited. +func (s *BaseYQLListener) ExitType_name_or_bind(ctx *Type_name_or_bindContext) {} + +// EnterValue_constructor_literal is called when production value_constructor_literal is entered. +func (s *BaseYQLListener) EnterValue_constructor_literal(ctx *Value_constructor_literalContext) {} + +// ExitValue_constructor_literal is called when production value_constructor_literal is exited. +func (s *BaseYQLListener) ExitValue_constructor_literal(ctx *Value_constructor_literalContext) {} + +// EnterValue_constructor is called when production value_constructor is entered. +func (s *BaseYQLListener) EnterValue_constructor(ctx *Value_constructorContext) {} + +// ExitValue_constructor is called when production value_constructor is exited. +func (s *BaseYQLListener) ExitValue_constructor(ctx *Value_constructorContext) {} + +// EnterDeclare_stmt is called when production declare_stmt is entered. +func (s *BaseYQLListener) EnterDeclare_stmt(ctx *Declare_stmtContext) {} + +// ExitDeclare_stmt is called when production declare_stmt is exited. +func (s *BaseYQLListener) ExitDeclare_stmt(ctx *Declare_stmtContext) {} + +// EnterModule_path is called when production module_path is entered. +func (s *BaseYQLListener) EnterModule_path(ctx *Module_pathContext) {} + +// ExitModule_path is called when production module_path is exited. +func (s *BaseYQLListener) ExitModule_path(ctx *Module_pathContext) {} + +// EnterImport_stmt is called when production import_stmt is entered. +func (s *BaseYQLListener) EnterImport_stmt(ctx *Import_stmtContext) {} + +// ExitImport_stmt is called when production import_stmt is exited. +func (s *BaseYQLListener) ExitImport_stmt(ctx *Import_stmtContext) {} + +// EnterExport_stmt is called when production export_stmt is entered. +func (s *BaseYQLListener) EnterExport_stmt(ctx *Export_stmtContext) {} + +// ExitExport_stmt is called when production export_stmt is exited. +func (s *BaseYQLListener) ExitExport_stmt(ctx *Export_stmtContext) {} + +// EnterCall_action is called when production call_action is entered. +func (s *BaseYQLListener) EnterCall_action(ctx *Call_actionContext) {} + +// ExitCall_action is called when production call_action is exited. +func (s *BaseYQLListener) ExitCall_action(ctx *Call_actionContext) {} + +// EnterInline_action is called when production inline_action is entered. +func (s *BaseYQLListener) EnterInline_action(ctx *Inline_actionContext) {} + +// ExitInline_action is called when production inline_action is exited. +func (s *BaseYQLListener) ExitInline_action(ctx *Inline_actionContext) {} + +// EnterDo_stmt is called when production do_stmt is entered. +func (s *BaseYQLListener) EnterDo_stmt(ctx *Do_stmtContext) {} + +// ExitDo_stmt is called when production do_stmt is exited. +func (s *BaseYQLListener) ExitDo_stmt(ctx *Do_stmtContext) {} + +// EnterPragma_stmt is called when production pragma_stmt is entered. +func (s *BaseYQLListener) EnterPragma_stmt(ctx *Pragma_stmtContext) {} + +// ExitPragma_stmt is called when production pragma_stmt is exited. +func (s *BaseYQLListener) ExitPragma_stmt(ctx *Pragma_stmtContext) {} + +// EnterPragma_value is called when production pragma_value is entered. +func (s *BaseYQLListener) EnterPragma_value(ctx *Pragma_valueContext) {} + +// ExitPragma_value is called when production pragma_value is exited. +func (s *BaseYQLListener) ExitPragma_value(ctx *Pragma_valueContext) {} + +// EnterSort_specification is called when production sort_specification is entered. +func (s *BaseYQLListener) EnterSort_specification(ctx *Sort_specificationContext) {} + +// ExitSort_specification is called when production sort_specification is exited. +func (s *BaseYQLListener) ExitSort_specification(ctx *Sort_specificationContext) {} + +// EnterSort_specification_list is called when production sort_specification_list is entered. +func (s *BaseYQLListener) EnterSort_specification_list(ctx *Sort_specification_listContext) {} + +// ExitSort_specification_list is called when production sort_specification_list is exited. +func (s *BaseYQLListener) ExitSort_specification_list(ctx *Sort_specification_listContext) {} + +// EnterSelect_stmt is called when production select_stmt is entered. +func (s *BaseYQLListener) EnterSelect_stmt(ctx *Select_stmtContext) {} + +// ExitSelect_stmt is called when production select_stmt is exited. +func (s *BaseYQLListener) ExitSelect_stmt(ctx *Select_stmtContext) {} + +// EnterSelect_unparenthesized_stmt is called when production select_unparenthesized_stmt is entered. +func (s *BaseYQLListener) EnterSelect_unparenthesized_stmt(ctx *Select_unparenthesized_stmtContext) {} + +// ExitSelect_unparenthesized_stmt is called when production select_unparenthesized_stmt is exited. +func (s *BaseYQLListener) ExitSelect_unparenthesized_stmt(ctx *Select_unparenthesized_stmtContext) {} + +// EnterSelect_kind_parenthesis is called when production select_kind_parenthesis is entered. +func (s *BaseYQLListener) EnterSelect_kind_parenthesis(ctx *Select_kind_parenthesisContext) {} + +// ExitSelect_kind_parenthesis is called when production select_kind_parenthesis is exited. +func (s *BaseYQLListener) ExitSelect_kind_parenthesis(ctx *Select_kind_parenthesisContext) {} + +// EnterSelect_op is called when production select_op is entered. +func (s *BaseYQLListener) EnterSelect_op(ctx *Select_opContext) {} + +// ExitSelect_op is called when production select_op is exited. +func (s *BaseYQLListener) ExitSelect_op(ctx *Select_opContext) {} + +// EnterSelect_kind_partial is called when production select_kind_partial is entered. +func (s *BaseYQLListener) EnterSelect_kind_partial(ctx *Select_kind_partialContext) {} + +// ExitSelect_kind_partial is called when production select_kind_partial is exited. +func (s *BaseYQLListener) ExitSelect_kind_partial(ctx *Select_kind_partialContext) {} + +// EnterSelect_kind is called when production select_kind is entered. +func (s *BaseYQLListener) EnterSelect_kind(ctx *Select_kindContext) {} + +// ExitSelect_kind is called when production select_kind is exited. +func (s *BaseYQLListener) ExitSelect_kind(ctx *Select_kindContext) {} + +// EnterProcess_core is called when production process_core is entered. +func (s *BaseYQLListener) EnterProcess_core(ctx *Process_coreContext) {} + +// ExitProcess_core is called when production process_core is exited. +func (s *BaseYQLListener) ExitProcess_core(ctx *Process_coreContext) {} + +// EnterExternal_call_param is called when production external_call_param is entered. +func (s *BaseYQLListener) EnterExternal_call_param(ctx *External_call_paramContext) {} + +// ExitExternal_call_param is called when production external_call_param is exited. +func (s *BaseYQLListener) ExitExternal_call_param(ctx *External_call_paramContext) {} + +// EnterExternal_call_settings is called when production external_call_settings is entered. +func (s *BaseYQLListener) EnterExternal_call_settings(ctx *External_call_settingsContext) {} + +// ExitExternal_call_settings is called when production external_call_settings is exited. +func (s *BaseYQLListener) ExitExternal_call_settings(ctx *External_call_settingsContext) {} + +// EnterReduce_core is called when production reduce_core is entered. +func (s *BaseYQLListener) EnterReduce_core(ctx *Reduce_coreContext) {} + +// ExitReduce_core is called when production reduce_core is exited. +func (s *BaseYQLListener) ExitReduce_core(ctx *Reduce_coreContext) {} + +// EnterOpt_set_quantifier is called when production opt_set_quantifier is entered. +func (s *BaseYQLListener) EnterOpt_set_quantifier(ctx *Opt_set_quantifierContext) {} + +// ExitOpt_set_quantifier is called when production opt_set_quantifier is exited. +func (s *BaseYQLListener) ExitOpt_set_quantifier(ctx *Opt_set_quantifierContext) {} + +// EnterSelect_core is called when production select_core is entered. +func (s *BaseYQLListener) EnterSelect_core(ctx *Select_coreContext) {} + +// ExitSelect_core is called when production select_core is exited. +func (s *BaseYQLListener) ExitSelect_core(ctx *Select_coreContext) {} + +// EnterRow_pattern_recognition_clause is called when production row_pattern_recognition_clause is entered. +func (s *BaseYQLListener) EnterRow_pattern_recognition_clause(ctx *Row_pattern_recognition_clauseContext) {} + +// ExitRow_pattern_recognition_clause is called when production row_pattern_recognition_clause is exited. +func (s *BaseYQLListener) ExitRow_pattern_recognition_clause(ctx *Row_pattern_recognition_clauseContext) {} + +// EnterRow_pattern_rows_per_match is called when production row_pattern_rows_per_match is entered. +func (s *BaseYQLListener) EnterRow_pattern_rows_per_match(ctx *Row_pattern_rows_per_matchContext) {} + +// ExitRow_pattern_rows_per_match is called when production row_pattern_rows_per_match is exited. +func (s *BaseYQLListener) ExitRow_pattern_rows_per_match(ctx *Row_pattern_rows_per_matchContext) {} + +// EnterRow_pattern_empty_match_handling is called when production row_pattern_empty_match_handling is entered. +func (s *BaseYQLListener) EnterRow_pattern_empty_match_handling(ctx *Row_pattern_empty_match_handlingContext) {} + +// ExitRow_pattern_empty_match_handling is called when production row_pattern_empty_match_handling is exited. +func (s *BaseYQLListener) ExitRow_pattern_empty_match_handling(ctx *Row_pattern_empty_match_handlingContext) {} + +// EnterRow_pattern_measures is called when production row_pattern_measures is entered. +func (s *BaseYQLListener) EnterRow_pattern_measures(ctx *Row_pattern_measuresContext) {} + +// ExitRow_pattern_measures is called when production row_pattern_measures is exited. +func (s *BaseYQLListener) ExitRow_pattern_measures(ctx *Row_pattern_measuresContext) {} + +// EnterRow_pattern_measure_list is called when production row_pattern_measure_list is entered. +func (s *BaseYQLListener) EnterRow_pattern_measure_list(ctx *Row_pattern_measure_listContext) {} + +// ExitRow_pattern_measure_list is called when production row_pattern_measure_list is exited. +func (s *BaseYQLListener) ExitRow_pattern_measure_list(ctx *Row_pattern_measure_listContext) {} + +// EnterRow_pattern_measure_definition is called when production row_pattern_measure_definition is entered. +func (s *BaseYQLListener) EnterRow_pattern_measure_definition(ctx *Row_pattern_measure_definitionContext) {} + +// ExitRow_pattern_measure_definition is called when production row_pattern_measure_definition is exited. +func (s *BaseYQLListener) ExitRow_pattern_measure_definition(ctx *Row_pattern_measure_definitionContext) {} + +// EnterRow_pattern_common_syntax is called when production row_pattern_common_syntax is entered. +func (s *BaseYQLListener) EnterRow_pattern_common_syntax(ctx *Row_pattern_common_syntaxContext) {} + +// ExitRow_pattern_common_syntax is called when production row_pattern_common_syntax is exited. +func (s *BaseYQLListener) ExitRow_pattern_common_syntax(ctx *Row_pattern_common_syntaxContext) {} + +// EnterRow_pattern_skip_to is called when production row_pattern_skip_to is entered. +func (s *BaseYQLListener) EnterRow_pattern_skip_to(ctx *Row_pattern_skip_toContext) {} + +// ExitRow_pattern_skip_to is called when production row_pattern_skip_to is exited. +func (s *BaseYQLListener) ExitRow_pattern_skip_to(ctx *Row_pattern_skip_toContext) {} + +// EnterRow_pattern_skip_to_variable_name is called when production row_pattern_skip_to_variable_name is entered. +func (s *BaseYQLListener) EnterRow_pattern_skip_to_variable_name(ctx *Row_pattern_skip_to_variable_nameContext) {} + +// ExitRow_pattern_skip_to_variable_name is called when production row_pattern_skip_to_variable_name is exited. +func (s *BaseYQLListener) ExitRow_pattern_skip_to_variable_name(ctx *Row_pattern_skip_to_variable_nameContext) {} + +// EnterRow_pattern_initial_or_seek is called when production row_pattern_initial_or_seek is entered. +func (s *BaseYQLListener) EnterRow_pattern_initial_or_seek(ctx *Row_pattern_initial_or_seekContext) {} + +// ExitRow_pattern_initial_or_seek is called when production row_pattern_initial_or_seek is exited. +func (s *BaseYQLListener) ExitRow_pattern_initial_or_seek(ctx *Row_pattern_initial_or_seekContext) {} + +// EnterRow_pattern is called when production row_pattern is entered. +func (s *BaseYQLListener) EnterRow_pattern(ctx *Row_patternContext) {} + +// ExitRow_pattern is called when production row_pattern is exited. +func (s *BaseYQLListener) ExitRow_pattern(ctx *Row_patternContext) {} + +// EnterRow_pattern_term is called when production row_pattern_term is entered. +func (s *BaseYQLListener) EnterRow_pattern_term(ctx *Row_pattern_termContext) {} + +// ExitRow_pattern_term is called when production row_pattern_term is exited. +func (s *BaseYQLListener) ExitRow_pattern_term(ctx *Row_pattern_termContext) {} + +// EnterRow_pattern_factor is called when production row_pattern_factor is entered. +func (s *BaseYQLListener) EnterRow_pattern_factor(ctx *Row_pattern_factorContext) {} + +// ExitRow_pattern_factor is called when production row_pattern_factor is exited. +func (s *BaseYQLListener) ExitRow_pattern_factor(ctx *Row_pattern_factorContext) {} + +// EnterRow_pattern_quantifier is called when production row_pattern_quantifier is entered. +func (s *BaseYQLListener) EnterRow_pattern_quantifier(ctx *Row_pattern_quantifierContext) {} + +// ExitRow_pattern_quantifier is called when production row_pattern_quantifier is exited. +func (s *BaseYQLListener) ExitRow_pattern_quantifier(ctx *Row_pattern_quantifierContext) {} + +// EnterRow_pattern_primary is called when production row_pattern_primary is entered. +func (s *BaseYQLListener) EnterRow_pattern_primary(ctx *Row_pattern_primaryContext) {} + +// ExitRow_pattern_primary is called when production row_pattern_primary is exited. +func (s *BaseYQLListener) ExitRow_pattern_primary(ctx *Row_pattern_primaryContext) {} + +// EnterRow_pattern_primary_variable_name is called when production row_pattern_primary_variable_name is entered. +func (s *BaseYQLListener) EnterRow_pattern_primary_variable_name(ctx *Row_pattern_primary_variable_nameContext) {} + +// ExitRow_pattern_primary_variable_name is called when production row_pattern_primary_variable_name is exited. +func (s *BaseYQLListener) ExitRow_pattern_primary_variable_name(ctx *Row_pattern_primary_variable_nameContext) {} + +// EnterRow_pattern_permute is called when production row_pattern_permute is entered. +func (s *BaseYQLListener) EnterRow_pattern_permute(ctx *Row_pattern_permuteContext) {} + +// ExitRow_pattern_permute is called when production row_pattern_permute is exited. +func (s *BaseYQLListener) ExitRow_pattern_permute(ctx *Row_pattern_permuteContext) {} + +// EnterRow_pattern_subset_clause is called when production row_pattern_subset_clause is entered. +func (s *BaseYQLListener) EnterRow_pattern_subset_clause(ctx *Row_pattern_subset_clauseContext) {} + +// ExitRow_pattern_subset_clause is called when production row_pattern_subset_clause is exited. +func (s *BaseYQLListener) ExitRow_pattern_subset_clause(ctx *Row_pattern_subset_clauseContext) {} + +// EnterRow_pattern_subset_list is called when production row_pattern_subset_list is entered. +func (s *BaseYQLListener) EnterRow_pattern_subset_list(ctx *Row_pattern_subset_listContext) {} + +// ExitRow_pattern_subset_list is called when production row_pattern_subset_list is exited. +func (s *BaseYQLListener) ExitRow_pattern_subset_list(ctx *Row_pattern_subset_listContext) {} + +// EnterRow_pattern_subset_item is called when production row_pattern_subset_item is entered. +func (s *BaseYQLListener) EnterRow_pattern_subset_item(ctx *Row_pattern_subset_itemContext) {} + +// ExitRow_pattern_subset_item is called when production row_pattern_subset_item is exited. +func (s *BaseYQLListener) ExitRow_pattern_subset_item(ctx *Row_pattern_subset_itemContext) {} + +// EnterRow_pattern_subset_item_variable_name is called when production row_pattern_subset_item_variable_name is entered. +func (s *BaseYQLListener) EnterRow_pattern_subset_item_variable_name(ctx *Row_pattern_subset_item_variable_nameContext) {} + +// ExitRow_pattern_subset_item_variable_name is called when production row_pattern_subset_item_variable_name is exited. +func (s *BaseYQLListener) ExitRow_pattern_subset_item_variable_name(ctx *Row_pattern_subset_item_variable_nameContext) {} + +// EnterRow_pattern_subset_rhs is called when production row_pattern_subset_rhs is entered. +func (s *BaseYQLListener) EnterRow_pattern_subset_rhs(ctx *Row_pattern_subset_rhsContext) {} + +// ExitRow_pattern_subset_rhs is called when production row_pattern_subset_rhs is exited. +func (s *BaseYQLListener) ExitRow_pattern_subset_rhs(ctx *Row_pattern_subset_rhsContext) {} + +// EnterRow_pattern_subset_rhs_variable_name is called when production row_pattern_subset_rhs_variable_name is entered. +func (s *BaseYQLListener) EnterRow_pattern_subset_rhs_variable_name(ctx *Row_pattern_subset_rhs_variable_nameContext) {} + +// ExitRow_pattern_subset_rhs_variable_name is called when production row_pattern_subset_rhs_variable_name is exited. +func (s *BaseYQLListener) ExitRow_pattern_subset_rhs_variable_name(ctx *Row_pattern_subset_rhs_variable_nameContext) {} + +// EnterRow_pattern_definition_list is called when production row_pattern_definition_list is entered. +func (s *BaseYQLListener) EnterRow_pattern_definition_list(ctx *Row_pattern_definition_listContext) {} + +// ExitRow_pattern_definition_list is called when production row_pattern_definition_list is exited. +func (s *BaseYQLListener) ExitRow_pattern_definition_list(ctx *Row_pattern_definition_listContext) {} + +// EnterRow_pattern_definition is called when production row_pattern_definition is entered. +func (s *BaseYQLListener) EnterRow_pattern_definition(ctx *Row_pattern_definitionContext) {} + +// ExitRow_pattern_definition is called when production row_pattern_definition is exited. +func (s *BaseYQLListener) ExitRow_pattern_definition(ctx *Row_pattern_definitionContext) {} + +// EnterRow_pattern_definition_variable_name is called when production row_pattern_definition_variable_name is entered. +func (s *BaseYQLListener) EnterRow_pattern_definition_variable_name(ctx *Row_pattern_definition_variable_nameContext) {} + +// ExitRow_pattern_definition_variable_name is called when production row_pattern_definition_variable_name is exited. +func (s *BaseYQLListener) ExitRow_pattern_definition_variable_name(ctx *Row_pattern_definition_variable_nameContext) {} + +// EnterRow_pattern_definition_search_condition is called when production row_pattern_definition_search_condition is entered. +func (s *BaseYQLListener) EnterRow_pattern_definition_search_condition(ctx *Row_pattern_definition_search_conditionContext) {} + +// ExitRow_pattern_definition_search_condition is called when production row_pattern_definition_search_condition is exited. +func (s *BaseYQLListener) ExitRow_pattern_definition_search_condition(ctx *Row_pattern_definition_search_conditionContext) {} + +// EnterSearch_condition is called when production search_condition is entered. +func (s *BaseYQLListener) EnterSearch_condition(ctx *Search_conditionContext) {} + +// ExitSearch_condition is called when production search_condition is exited. +func (s *BaseYQLListener) ExitSearch_condition(ctx *Search_conditionContext) {} + +// EnterRow_pattern_variable_name is called when production row_pattern_variable_name is entered. +func (s *BaseYQLListener) EnterRow_pattern_variable_name(ctx *Row_pattern_variable_nameContext) {} + +// ExitRow_pattern_variable_name is called when production row_pattern_variable_name is exited. +func (s *BaseYQLListener) ExitRow_pattern_variable_name(ctx *Row_pattern_variable_nameContext) {} + +// EnterOrder_by_clause is called when production order_by_clause is entered. +func (s *BaseYQLListener) EnterOrder_by_clause(ctx *Order_by_clauseContext) {} + +// ExitOrder_by_clause is called when production order_by_clause is exited. +func (s *BaseYQLListener) ExitOrder_by_clause(ctx *Order_by_clauseContext) {} + +// EnterExt_order_by_clause is called when production ext_order_by_clause is entered. +func (s *BaseYQLListener) EnterExt_order_by_clause(ctx *Ext_order_by_clauseContext) {} + +// ExitExt_order_by_clause is called when production ext_order_by_clause is exited. +func (s *BaseYQLListener) ExitExt_order_by_clause(ctx *Ext_order_by_clauseContext) {} + +// EnterGroup_by_clause is called when production group_by_clause is entered. +func (s *BaseYQLListener) EnterGroup_by_clause(ctx *Group_by_clauseContext) {} + +// ExitGroup_by_clause is called when production group_by_clause is exited. +func (s *BaseYQLListener) ExitGroup_by_clause(ctx *Group_by_clauseContext) {} + +// EnterGrouping_element_list is called when production grouping_element_list is entered. +func (s *BaseYQLListener) EnterGrouping_element_list(ctx *Grouping_element_listContext) {} + +// ExitGrouping_element_list is called when production grouping_element_list is exited. +func (s *BaseYQLListener) ExitGrouping_element_list(ctx *Grouping_element_listContext) {} + +// EnterGrouping_element is called when production grouping_element is entered. +func (s *BaseYQLListener) EnterGrouping_element(ctx *Grouping_elementContext) {} + +// ExitGrouping_element is called when production grouping_element is exited. +func (s *BaseYQLListener) ExitGrouping_element(ctx *Grouping_elementContext) {} + +// EnterOrdinary_grouping_set is called when production ordinary_grouping_set is entered. +func (s *BaseYQLListener) EnterOrdinary_grouping_set(ctx *Ordinary_grouping_setContext) {} + +// ExitOrdinary_grouping_set is called when production ordinary_grouping_set is exited. +func (s *BaseYQLListener) ExitOrdinary_grouping_set(ctx *Ordinary_grouping_setContext) {} + +// EnterOrdinary_grouping_set_list is called when production ordinary_grouping_set_list is entered. +func (s *BaseYQLListener) EnterOrdinary_grouping_set_list(ctx *Ordinary_grouping_set_listContext) {} + +// ExitOrdinary_grouping_set_list is called when production ordinary_grouping_set_list is exited. +func (s *BaseYQLListener) ExitOrdinary_grouping_set_list(ctx *Ordinary_grouping_set_listContext) {} + +// EnterRollup_list is called when production rollup_list is entered. +func (s *BaseYQLListener) EnterRollup_list(ctx *Rollup_listContext) {} + +// ExitRollup_list is called when production rollup_list is exited. +func (s *BaseYQLListener) ExitRollup_list(ctx *Rollup_listContext) {} + +// EnterCube_list is called when production cube_list is entered. +func (s *BaseYQLListener) EnterCube_list(ctx *Cube_listContext) {} + +// ExitCube_list is called when production cube_list is exited. +func (s *BaseYQLListener) ExitCube_list(ctx *Cube_listContext) {} + +// EnterGrouping_sets_specification is called when production grouping_sets_specification is entered. +func (s *BaseYQLListener) EnterGrouping_sets_specification(ctx *Grouping_sets_specificationContext) {} + +// ExitGrouping_sets_specification is called when production grouping_sets_specification is exited. +func (s *BaseYQLListener) ExitGrouping_sets_specification(ctx *Grouping_sets_specificationContext) {} + +// EnterHopping_window_specification is called when production hopping_window_specification is entered. +func (s *BaseYQLListener) EnterHopping_window_specification(ctx *Hopping_window_specificationContext) {} + +// ExitHopping_window_specification is called when production hopping_window_specification is exited. +func (s *BaseYQLListener) ExitHopping_window_specification(ctx *Hopping_window_specificationContext) {} + +// EnterResult_column is called when production result_column is entered. +func (s *BaseYQLListener) EnterResult_column(ctx *Result_columnContext) {} + +// ExitResult_column is called when production result_column is exited. +func (s *BaseYQLListener) ExitResult_column(ctx *Result_columnContext) {} + +// EnterJoin_source is called when production join_source is entered. +func (s *BaseYQLListener) EnterJoin_source(ctx *Join_sourceContext) {} + +// ExitJoin_source is called when production join_source is exited. +func (s *BaseYQLListener) ExitJoin_source(ctx *Join_sourceContext) {} + +// EnterNamed_column is called when production named_column is entered. +func (s *BaseYQLListener) EnterNamed_column(ctx *Named_columnContext) {} + +// ExitNamed_column is called when production named_column is exited. +func (s *BaseYQLListener) ExitNamed_column(ctx *Named_columnContext) {} + +// EnterFlatten_by_arg is called when production flatten_by_arg is entered. +func (s *BaseYQLListener) EnterFlatten_by_arg(ctx *Flatten_by_argContext) {} + +// ExitFlatten_by_arg is called when production flatten_by_arg is exited. +func (s *BaseYQLListener) ExitFlatten_by_arg(ctx *Flatten_by_argContext) {} + +// EnterFlatten_source is called when production flatten_source is entered. +func (s *BaseYQLListener) EnterFlatten_source(ctx *Flatten_sourceContext) {} + +// ExitFlatten_source is called when production flatten_source is exited. +func (s *BaseYQLListener) ExitFlatten_source(ctx *Flatten_sourceContext) {} + +// EnterNamed_single_source is called when production named_single_source is entered. +func (s *BaseYQLListener) EnterNamed_single_source(ctx *Named_single_sourceContext) {} + +// ExitNamed_single_source is called when production named_single_source is exited. +func (s *BaseYQLListener) ExitNamed_single_source(ctx *Named_single_sourceContext) {} + +// EnterSingle_source is called when production single_source is entered. +func (s *BaseYQLListener) EnterSingle_source(ctx *Single_sourceContext) {} + +// ExitSingle_source is called when production single_source is exited. +func (s *BaseYQLListener) ExitSingle_source(ctx *Single_sourceContext) {} + +// EnterSample_clause is called when production sample_clause is entered. +func (s *BaseYQLListener) EnterSample_clause(ctx *Sample_clauseContext) {} + +// ExitSample_clause is called when production sample_clause is exited. +func (s *BaseYQLListener) ExitSample_clause(ctx *Sample_clauseContext) {} + +// EnterTablesample_clause is called when production tablesample_clause is entered. +func (s *BaseYQLListener) EnterTablesample_clause(ctx *Tablesample_clauseContext) {} + +// ExitTablesample_clause is called when production tablesample_clause is exited. +func (s *BaseYQLListener) ExitTablesample_clause(ctx *Tablesample_clauseContext) {} + +// EnterSampling_mode is called when production sampling_mode is entered. +func (s *BaseYQLListener) EnterSampling_mode(ctx *Sampling_modeContext) {} + +// ExitSampling_mode is called when production sampling_mode is exited. +func (s *BaseYQLListener) ExitSampling_mode(ctx *Sampling_modeContext) {} + +// EnterRepeatable_clause is called when production repeatable_clause is entered. +func (s *BaseYQLListener) EnterRepeatable_clause(ctx *Repeatable_clauseContext) {} + +// ExitRepeatable_clause is called when production repeatable_clause is exited. +func (s *BaseYQLListener) ExitRepeatable_clause(ctx *Repeatable_clauseContext) {} + +// EnterJoin_op is called when production join_op is entered. +func (s *BaseYQLListener) EnterJoin_op(ctx *Join_opContext) {} + +// ExitJoin_op is called when production join_op is exited. +func (s *BaseYQLListener) ExitJoin_op(ctx *Join_opContext) {} + +// EnterJoin_constraint is called when production join_constraint is entered. +func (s *BaseYQLListener) EnterJoin_constraint(ctx *Join_constraintContext) {} + +// ExitJoin_constraint is called when production join_constraint is exited. +func (s *BaseYQLListener) ExitJoin_constraint(ctx *Join_constraintContext) {} + +// EnterReturning_columns_list is called when production returning_columns_list is entered. +func (s *BaseYQLListener) EnterReturning_columns_list(ctx *Returning_columns_listContext) {} + +// ExitReturning_columns_list is called when production returning_columns_list is exited. +func (s *BaseYQLListener) ExitReturning_columns_list(ctx *Returning_columns_listContext) {} + +// EnterInto_table_stmt is called when production into_table_stmt is entered. +func (s *BaseYQLListener) EnterInto_table_stmt(ctx *Into_table_stmtContext) {} + +// ExitInto_table_stmt is called when production into_table_stmt is exited. +func (s *BaseYQLListener) ExitInto_table_stmt(ctx *Into_table_stmtContext) {} + +// EnterInto_values_source is called when production into_values_source is entered. +func (s *BaseYQLListener) EnterInto_values_source(ctx *Into_values_sourceContext) {} + +// ExitInto_values_source is called when production into_values_source is exited. +func (s *BaseYQLListener) ExitInto_values_source(ctx *Into_values_sourceContext) {} + +// EnterValues_stmt is called when production values_stmt is entered. +func (s *BaseYQLListener) EnterValues_stmt(ctx *Values_stmtContext) {} + +// ExitValues_stmt is called when production values_stmt is exited. +func (s *BaseYQLListener) ExitValues_stmt(ctx *Values_stmtContext) {} + +// EnterValues_source is called when production values_source is entered. +func (s *BaseYQLListener) EnterValues_source(ctx *Values_sourceContext) {} + +// ExitValues_source is called when production values_source is exited. +func (s *BaseYQLListener) ExitValues_source(ctx *Values_sourceContext) {} + +// EnterValues_source_row_list is called when production values_source_row_list is entered. +func (s *BaseYQLListener) EnterValues_source_row_list(ctx *Values_source_row_listContext) {} + +// ExitValues_source_row_list is called when production values_source_row_list is exited. +func (s *BaseYQLListener) ExitValues_source_row_list(ctx *Values_source_row_listContext) {} + +// EnterValues_source_row is called when production values_source_row is entered. +func (s *BaseYQLListener) EnterValues_source_row(ctx *Values_source_rowContext) {} + +// ExitValues_source_row is called when production values_source_row is exited. +func (s *BaseYQLListener) ExitValues_source_row(ctx *Values_source_rowContext) {} + +// EnterSimple_values_source is called when production simple_values_source is entered. +func (s *BaseYQLListener) EnterSimple_values_source(ctx *Simple_values_sourceContext) {} + +// ExitSimple_values_source is called when production simple_values_source is exited. +func (s *BaseYQLListener) ExitSimple_values_source(ctx *Simple_values_sourceContext) {} + +// EnterCreate_external_data_source_stmt is called when production create_external_data_source_stmt is entered. +func (s *BaseYQLListener) EnterCreate_external_data_source_stmt(ctx *Create_external_data_source_stmtContext) {} + +// ExitCreate_external_data_source_stmt is called when production create_external_data_source_stmt is exited. +func (s *BaseYQLListener) ExitCreate_external_data_source_stmt(ctx *Create_external_data_source_stmtContext) {} + +// EnterAlter_external_data_source_stmt is called when production alter_external_data_source_stmt is entered. +func (s *BaseYQLListener) EnterAlter_external_data_source_stmt(ctx *Alter_external_data_source_stmtContext) {} + +// ExitAlter_external_data_source_stmt is called when production alter_external_data_source_stmt is exited. +func (s *BaseYQLListener) ExitAlter_external_data_source_stmt(ctx *Alter_external_data_source_stmtContext) {} + +// EnterAlter_external_data_source_action is called when production alter_external_data_source_action is entered. +func (s *BaseYQLListener) EnterAlter_external_data_source_action(ctx *Alter_external_data_source_actionContext) {} + +// ExitAlter_external_data_source_action is called when production alter_external_data_source_action is exited. +func (s *BaseYQLListener) ExitAlter_external_data_source_action(ctx *Alter_external_data_source_actionContext) {} + +// EnterDrop_external_data_source_stmt is called when production drop_external_data_source_stmt is entered. +func (s *BaseYQLListener) EnterDrop_external_data_source_stmt(ctx *Drop_external_data_source_stmtContext) {} + +// ExitDrop_external_data_source_stmt is called when production drop_external_data_source_stmt is exited. +func (s *BaseYQLListener) ExitDrop_external_data_source_stmt(ctx *Drop_external_data_source_stmtContext) {} + +// EnterCreate_view_stmt is called when production create_view_stmt is entered. +func (s *BaseYQLListener) EnterCreate_view_stmt(ctx *Create_view_stmtContext) {} + +// ExitCreate_view_stmt is called when production create_view_stmt is exited. +func (s *BaseYQLListener) ExitCreate_view_stmt(ctx *Create_view_stmtContext) {} + +// EnterDrop_view_stmt is called when production drop_view_stmt is entered. +func (s *BaseYQLListener) EnterDrop_view_stmt(ctx *Drop_view_stmtContext) {} + +// ExitDrop_view_stmt is called when production drop_view_stmt is exited. +func (s *BaseYQLListener) ExitDrop_view_stmt(ctx *Drop_view_stmtContext) {} + +// EnterUpsert_object_stmt is called when production upsert_object_stmt is entered. +func (s *BaseYQLListener) EnterUpsert_object_stmt(ctx *Upsert_object_stmtContext) {} + +// ExitUpsert_object_stmt is called when production upsert_object_stmt is exited. +func (s *BaseYQLListener) ExitUpsert_object_stmt(ctx *Upsert_object_stmtContext) {} + +// EnterCreate_object_stmt is called when production create_object_stmt is entered. +func (s *BaseYQLListener) EnterCreate_object_stmt(ctx *Create_object_stmtContext) {} + +// ExitCreate_object_stmt is called when production create_object_stmt is exited. +func (s *BaseYQLListener) ExitCreate_object_stmt(ctx *Create_object_stmtContext) {} + +// EnterCreate_object_features is called when production create_object_features is entered. +func (s *BaseYQLListener) EnterCreate_object_features(ctx *Create_object_featuresContext) {} + +// ExitCreate_object_features is called when production create_object_features is exited. +func (s *BaseYQLListener) ExitCreate_object_features(ctx *Create_object_featuresContext) {} + +// EnterAlter_object_stmt is called when production alter_object_stmt is entered. +func (s *BaseYQLListener) EnterAlter_object_stmt(ctx *Alter_object_stmtContext) {} + +// ExitAlter_object_stmt is called when production alter_object_stmt is exited. +func (s *BaseYQLListener) ExitAlter_object_stmt(ctx *Alter_object_stmtContext) {} + +// EnterAlter_object_features is called when production alter_object_features is entered. +func (s *BaseYQLListener) EnterAlter_object_features(ctx *Alter_object_featuresContext) {} + +// ExitAlter_object_features is called when production alter_object_features is exited. +func (s *BaseYQLListener) ExitAlter_object_features(ctx *Alter_object_featuresContext) {} + +// EnterDrop_object_stmt is called when production drop_object_stmt is entered. +func (s *BaseYQLListener) EnterDrop_object_stmt(ctx *Drop_object_stmtContext) {} + +// ExitDrop_object_stmt is called when production drop_object_stmt is exited. +func (s *BaseYQLListener) ExitDrop_object_stmt(ctx *Drop_object_stmtContext) {} + +// EnterDrop_object_features is called when production drop_object_features is entered. +func (s *BaseYQLListener) EnterDrop_object_features(ctx *Drop_object_featuresContext) {} + +// ExitDrop_object_features is called when production drop_object_features is exited. +func (s *BaseYQLListener) ExitDrop_object_features(ctx *Drop_object_featuresContext) {} + +// EnterObject_feature_value is called when production object_feature_value is entered. +func (s *BaseYQLListener) EnterObject_feature_value(ctx *Object_feature_valueContext) {} + +// ExitObject_feature_value is called when production object_feature_value is exited. +func (s *BaseYQLListener) ExitObject_feature_value(ctx *Object_feature_valueContext) {} + +// EnterObject_feature_kv is called when production object_feature_kv is entered. +func (s *BaseYQLListener) EnterObject_feature_kv(ctx *Object_feature_kvContext) {} + +// ExitObject_feature_kv is called when production object_feature_kv is exited. +func (s *BaseYQLListener) ExitObject_feature_kv(ctx *Object_feature_kvContext) {} + +// EnterObject_feature_flag is called when production object_feature_flag is entered. +func (s *BaseYQLListener) EnterObject_feature_flag(ctx *Object_feature_flagContext) {} + +// ExitObject_feature_flag is called when production object_feature_flag is exited. +func (s *BaseYQLListener) ExitObject_feature_flag(ctx *Object_feature_flagContext) {} + +// EnterObject_feature is called when production object_feature is entered. +func (s *BaseYQLListener) EnterObject_feature(ctx *Object_featureContext) {} + +// ExitObject_feature is called when production object_feature is exited. +func (s *BaseYQLListener) ExitObject_feature(ctx *Object_featureContext) {} + +// EnterObject_features is called when production object_features is entered. +func (s *BaseYQLListener) EnterObject_features(ctx *Object_featuresContext) {} + +// ExitObject_features is called when production object_features is exited. +func (s *BaseYQLListener) ExitObject_features(ctx *Object_featuresContext) {} + +// EnterObject_type_ref is called when production object_type_ref is entered. +func (s *BaseYQLListener) EnterObject_type_ref(ctx *Object_type_refContext) {} + +// ExitObject_type_ref is called when production object_type_ref is exited. +func (s *BaseYQLListener) ExitObject_type_ref(ctx *Object_type_refContext) {} + +// EnterCreate_table_stmt is called when production create_table_stmt is entered. +func (s *BaseYQLListener) EnterCreate_table_stmt(ctx *Create_table_stmtContext) {} + +// ExitCreate_table_stmt is called when production create_table_stmt is exited. +func (s *BaseYQLListener) ExitCreate_table_stmt(ctx *Create_table_stmtContext) {} + +// EnterCreate_table_entry is called when production create_table_entry is entered. +func (s *BaseYQLListener) EnterCreate_table_entry(ctx *Create_table_entryContext) {} + +// ExitCreate_table_entry is called when production create_table_entry is exited. +func (s *BaseYQLListener) ExitCreate_table_entry(ctx *Create_table_entryContext) {} + +// EnterCreate_backup_collection_stmt is called when production create_backup_collection_stmt is entered. +func (s *BaseYQLListener) EnterCreate_backup_collection_stmt(ctx *Create_backup_collection_stmtContext) {} + +// ExitCreate_backup_collection_stmt is called when production create_backup_collection_stmt is exited. +func (s *BaseYQLListener) ExitCreate_backup_collection_stmt(ctx *Create_backup_collection_stmtContext) {} + +// EnterAlter_backup_collection_stmt is called when production alter_backup_collection_stmt is entered. +func (s *BaseYQLListener) EnterAlter_backup_collection_stmt(ctx *Alter_backup_collection_stmtContext) {} + +// ExitAlter_backup_collection_stmt is called when production alter_backup_collection_stmt is exited. +func (s *BaseYQLListener) ExitAlter_backup_collection_stmt(ctx *Alter_backup_collection_stmtContext) {} + +// EnterDrop_backup_collection_stmt is called when production drop_backup_collection_stmt is entered. +func (s *BaseYQLListener) EnterDrop_backup_collection_stmt(ctx *Drop_backup_collection_stmtContext) {} + +// ExitDrop_backup_collection_stmt is called when production drop_backup_collection_stmt is exited. +func (s *BaseYQLListener) ExitDrop_backup_collection_stmt(ctx *Drop_backup_collection_stmtContext) {} + +// EnterCreate_backup_collection_entries is called when production create_backup_collection_entries is entered. +func (s *BaseYQLListener) EnterCreate_backup_collection_entries(ctx *Create_backup_collection_entriesContext) {} + +// ExitCreate_backup_collection_entries is called when production create_backup_collection_entries is exited. +func (s *BaseYQLListener) ExitCreate_backup_collection_entries(ctx *Create_backup_collection_entriesContext) {} + +// EnterCreate_backup_collection_entries_many is called when production create_backup_collection_entries_many is entered. +func (s *BaseYQLListener) EnterCreate_backup_collection_entries_many(ctx *Create_backup_collection_entries_manyContext) {} + +// ExitCreate_backup_collection_entries_many is called when production create_backup_collection_entries_many is exited. +func (s *BaseYQLListener) ExitCreate_backup_collection_entries_many(ctx *Create_backup_collection_entries_manyContext) {} + +// EnterTable_list is called when production table_list is entered. +func (s *BaseYQLListener) EnterTable_list(ctx *Table_listContext) {} + +// ExitTable_list is called when production table_list is exited. +func (s *BaseYQLListener) ExitTable_list(ctx *Table_listContext) {} + +// EnterAlter_backup_collection_actions is called when production alter_backup_collection_actions is entered. +func (s *BaseYQLListener) EnterAlter_backup_collection_actions(ctx *Alter_backup_collection_actionsContext) {} + +// ExitAlter_backup_collection_actions is called when production alter_backup_collection_actions is exited. +func (s *BaseYQLListener) ExitAlter_backup_collection_actions(ctx *Alter_backup_collection_actionsContext) {} + +// EnterAlter_backup_collection_action is called when production alter_backup_collection_action is entered. +func (s *BaseYQLListener) EnterAlter_backup_collection_action(ctx *Alter_backup_collection_actionContext) {} + +// ExitAlter_backup_collection_action is called when production alter_backup_collection_action is exited. +func (s *BaseYQLListener) ExitAlter_backup_collection_action(ctx *Alter_backup_collection_actionContext) {} + +// EnterAlter_backup_collection_entries is called when production alter_backup_collection_entries is entered. +func (s *BaseYQLListener) EnterAlter_backup_collection_entries(ctx *Alter_backup_collection_entriesContext) {} + +// ExitAlter_backup_collection_entries is called when production alter_backup_collection_entries is exited. +func (s *BaseYQLListener) ExitAlter_backup_collection_entries(ctx *Alter_backup_collection_entriesContext) {} + +// EnterAlter_backup_collection_entry is called when production alter_backup_collection_entry is entered. +func (s *BaseYQLListener) EnterAlter_backup_collection_entry(ctx *Alter_backup_collection_entryContext) {} + +// ExitAlter_backup_collection_entry is called when production alter_backup_collection_entry is exited. +func (s *BaseYQLListener) ExitAlter_backup_collection_entry(ctx *Alter_backup_collection_entryContext) {} + +// EnterBackup_collection is called when production backup_collection is entered. +func (s *BaseYQLListener) EnterBackup_collection(ctx *Backup_collectionContext) {} + +// ExitBackup_collection is called when production backup_collection is exited. +func (s *BaseYQLListener) ExitBackup_collection(ctx *Backup_collectionContext) {} + +// EnterBackup_collection_settings is called when production backup_collection_settings is entered. +func (s *BaseYQLListener) EnterBackup_collection_settings(ctx *Backup_collection_settingsContext) {} + +// ExitBackup_collection_settings is called when production backup_collection_settings is exited. +func (s *BaseYQLListener) ExitBackup_collection_settings(ctx *Backup_collection_settingsContext) {} + +// EnterBackup_collection_settings_entry is called when production backup_collection_settings_entry is entered. +func (s *BaseYQLListener) EnterBackup_collection_settings_entry(ctx *Backup_collection_settings_entryContext) {} + +// ExitBackup_collection_settings_entry is called when production backup_collection_settings_entry is exited. +func (s *BaseYQLListener) ExitBackup_collection_settings_entry(ctx *Backup_collection_settings_entryContext) {} + +// EnterBackup_stmt is called when production backup_stmt is entered. +func (s *BaseYQLListener) EnterBackup_stmt(ctx *Backup_stmtContext) {} + +// ExitBackup_stmt is called when production backup_stmt is exited. +func (s *BaseYQLListener) ExitBackup_stmt(ctx *Backup_stmtContext) {} + +// EnterRestore_stmt is called when production restore_stmt is entered. +func (s *BaseYQLListener) EnterRestore_stmt(ctx *Restore_stmtContext) {} + +// ExitRestore_stmt is called when production restore_stmt is exited. +func (s *BaseYQLListener) ExitRestore_stmt(ctx *Restore_stmtContext) {} + +// EnterTable_inherits is called when production table_inherits is entered. +func (s *BaseYQLListener) EnterTable_inherits(ctx *Table_inheritsContext) {} + +// ExitTable_inherits is called when production table_inherits is exited. +func (s *BaseYQLListener) ExitTable_inherits(ctx *Table_inheritsContext) {} + +// EnterTable_partition_by is called when production table_partition_by is entered. +func (s *BaseYQLListener) EnterTable_partition_by(ctx *Table_partition_byContext) {} + +// ExitTable_partition_by is called when production table_partition_by is exited. +func (s *BaseYQLListener) ExitTable_partition_by(ctx *Table_partition_byContext) {} + +// EnterWith_table_settings is called when production with_table_settings is entered. +func (s *BaseYQLListener) EnterWith_table_settings(ctx *With_table_settingsContext) {} + +// ExitWith_table_settings is called when production with_table_settings is exited. +func (s *BaseYQLListener) ExitWith_table_settings(ctx *With_table_settingsContext) {} + +// EnterTable_tablestore is called when production table_tablestore is entered. +func (s *BaseYQLListener) EnterTable_tablestore(ctx *Table_tablestoreContext) {} + +// ExitTable_tablestore is called when production table_tablestore is exited. +func (s *BaseYQLListener) ExitTable_tablestore(ctx *Table_tablestoreContext) {} + +// EnterTable_settings_entry is called when production table_settings_entry is entered. +func (s *BaseYQLListener) EnterTable_settings_entry(ctx *Table_settings_entryContext) {} + +// ExitTable_settings_entry is called when production table_settings_entry is exited. +func (s *BaseYQLListener) ExitTable_settings_entry(ctx *Table_settings_entryContext) {} + +// EnterTable_as_source is called when production table_as_source is entered. +func (s *BaseYQLListener) EnterTable_as_source(ctx *Table_as_sourceContext) {} + +// ExitTable_as_source is called when production table_as_source is exited. +func (s *BaseYQLListener) ExitTable_as_source(ctx *Table_as_sourceContext) {} + +// EnterAlter_table_stmt is called when production alter_table_stmt is entered. +func (s *BaseYQLListener) EnterAlter_table_stmt(ctx *Alter_table_stmtContext) {} + +// ExitAlter_table_stmt is called when production alter_table_stmt is exited. +func (s *BaseYQLListener) ExitAlter_table_stmt(ctx *Alter_table_stmtContext) {} + +// EnterAlter_table_action is called when production alter_table_action is entered. +func (s *BaseYQLListener) EnterAlter_table_action(ctx *Alter_table_actionContext) {} + +// ExitAlter_table_action is called when production alter_table_action is exited. +func (s *BaseYQLListener) ExitAlter_table_action(ctx *Alter_table_actionContext) {} + +// EnterAlter_external_table_stmt is called when production alter_external_table_stmt is entered. +func (s *BaseYQLListener) EnterAlter_external_table_stmt(ctx *Alter_external_table_stmtContext) {} + +// ExitAlter_external_table_stmt is called when production alter_external_table_stmt is exited. +func (s *BaseYQLListener) ExitAlter_external_table_stmt(ctx *Alter_external_table_stmtContext) {} + +// EnterAlter_external_table_action is called when production alter_external_table_action is entered. +func (s *BaseYQLListener) EnterAlter_external_table_action(ctx *Alter_external_table_actionContext) {} + +// ExitAlter_external_table_action is called when production alter_external_table_action is exited. +func (s *BaseYQLListener) ExitAlter_external_table_action(ctx *Alter_external_table_actionContext) {} + +// EnterAlter_table_store_stmt is called when production alter_table_store_stmt is entered. +func (s *BaseYQLListener) EnterAlter_table_store_stmt(ctx *Alter_table_store_stmtContext) {} + +// ExitAlter_table_store_stmt is called when production alter_table_store_stmt is exited. +func (s *BaseYQLListener) ExitAlter_table_store_stmt(ctx *Alter_table_store_stmtContext) {} + +// EnterAlter_table_store_action is called when production alter_table_store_action is entered. +func (s *BaseYQLListener) EnterAlter_table_store_action(ctx *Alter_table_store_actionContext) {} + +// ExitAlter_table_store_action is called when production alter_table_store_action is exited. +func (s *BaseYQLListener) ExitAlter_table_store_action(ctx *Alter_table_store_actionContext) {} + +// EnterAlter_table_add_column is called when production alter_table_add_column is entered. +func (s *BaseYQLListener) EnterAlter_table_add_column(ctx *Alter_table_add_columnContext) {} + +// ExitAlter_table_add_column is called when production alter_table_add_column is exited. +func (s *BaseYQLListener) ExitAlter_table_add_column(ctx *Alter_table_add_columnContext) {} + +// EnterAlter_table_drop_column is called when production alter_table_drop_column is entered. +func (s *BaseYQLListener) EnterAlter_table_drop_column(ctx *Alter_table_drop_columnContext) {} + +// ExitAlter_table_drop_column is called when production alter_table_drop_column is exited. +func (s *BaseYQLListener) ExitAlter_table_drop_column(ctx *Alter_table_drop_columnContext) {} + +// EnterAlter_table_alter_column is called when production alter_table_alter_column is entered. +func (s *BaseYQLListener) EnterAlter_table_alter_column(ctx *Alter_table_alter_columnContext) {} + +// ExitAlter_table_alter_column is called when production alter_table_alter_column is exited. +func (s *BaseYQLListener) ExitAlter_table_alter_column(ctx *Alter_table_alter_columnContext) {} + +// EnterAlter_table_alter_column_drop_not_null is called when production alter_table_alter_column_drop_not_null is entered. +func (s *BaseYQLListener) EnterAlter_table_alter_column_drop_not_null(ctx *Alter_table_alter_column_drop_not_nullContext) {} + +// ExitAlter_table_alter_column_drop_not_null is called when production alter_table_alter_column_drop_not_null is exited. +func (s *BaseYQLListener) ExitAlter_table_alter_column_drop_not_null(ctx *Alter_table_alter_column_drop_not_nullContext) {} + +// EnterAlter_table_add_column_family is called when production alter_table_add_column_family is entered. +func (s *BaseYQLListener) EnterAlter_table_add_column_family(ctx *Alter_table_add_column_familyContext) {} + +// ExitAlter_table_add_column_family is called when production alter_table_add_column_family is exited. +func (s *BaseYQLListener) ExitAlter_table_add_column_family(ctx *Alter_table_add_column_familyContext) {} + +// EnterAlter_table_alter_column_family is called when production alter_table_alter_column_family is entered. +func (s *BaseYQLListener) EnterAlter_table_alter_column_family(ctx *Alter_table_alter_column_familyContext) {} + +// ExitAlter_table_alter_column_family is called when production alter_table_alter_column_family is exited. +func (s *BaseYQLListener) ExitAlter_table_alter_column_family(ctx *Alter_table_alter_column_familyContext) {} + +// EnterAlter_table_set_table_setting_uncompat is called when production alter_table_set_table_setting_uncompat is entered. +func (s *BaseYQLListener) EnterAlter_table_set_table_setting_uncompat(ctx *Alter_table_set_table_setting_uncompatContext) {} + +// ExitAlter_table_set_table_setting_uncompat is called when production alter_table_set_table_setting_uncompat is exited. +func (s *BaseYQLListener) ExitAlter_table_set_table_setting_uncompat(ctx *Alter_table_set_table_setting_uncompatContext) {} + +// EnterAlter_table_set_table_setting_compat is called when production alter_table_set_table_setting_compat is entered. +func (s *BaseYQLListener) EnterAlter_table_set_table_setting_compat(ctx *Alter_table_set_table_setting_compatContext) {} + +// ExitAlter_table_set_table_setting_compat is called when production alter_table_set_table_setting_compat is exited. +func (s *BaseYQLListener) ExitAlter_table_set_table_setting_compat(ctx *Alter_table_set_table_setting_compatContext) {} + +// EnterAlter_table_reset_table_setting is called when production alter_table_reset_table_setting is entered. +func (s *BaseYQLListener) EnterAlter_table_reset_table_setting(ctx *Alter_table_reset_table_settingContext) {} + +// ExitAlter_table_reset_table_setting is called when production alter_table_reset_table_setting is exited. +func (s *BaseYQLListener) ExitAlter_table_reset_table_setting(ctx *Alter_table_reset_table_settingContext) {} + +// EnterAlter_table_add_index is called when production alter_table_add_index is entered. +func (s *BaseYQLListener) EnterAlter_table_add_index(ctx *Alter_table_add_indexContext) {} + +// ExitAlter_table_add_index is called when production alter_table_add_index is exited. +func (s *BaseYQLListener) ExitAlter_table_add_index(ctx *Alter_table_add_indexContext) {} + +// EnterAlter_table_drop_index is called when production alter_table_drop_index is entered. +func (s *BaseYQLListener) EnterAlter_table_drop_index(ctx *Alter_table_drop_indexContext) {} + +// ExitAlter_table_drop_index is called when production alter_table_drop_index is exited. +func (s *BaseYQLListener) ExitAlter_table_drop_index(ctx *Alter_table_drop_indexContext) {} + +// EnterAlter_table_rename_to is called when production alter_table_rename_to is entered. +func (s *BaseYQLListener) EnterAlter_table_rename_to(ctx *Alter_table_rename_toContext) {} + +// ExitAlter_table_rename_to is called when production alter_table_rename_to is exited. +func (s *BaseYQLListener) ExitAlter_table_rename_to(ctx *Alter_table_rename_toContext) {} + +// EnterAlter_table_rename_index_to is called when production alter_table_rename_index_to is entered. +func (s *BaseYQLListener) EnterAlter_table_rename_index_to(ctx *Alter_table_rename_index_toContext) {} + +// ExitAlter_table_rename_index_to is called when production alter_table_rename_index_to is exited. +func (s *BaseYQLListener) ExitAlter_table_rename_index_to(ctx *Alter_table_rename_index_toContext) {} + +// EnterAlter_table_add_changefeed is called when production alter_table_add_changefeed is entered. +func (s *BaseYQLListener) EnterAlter_table_add_changefeed(ctx *Alter_table_add_changefeedContext) {} + +// ExitAlter_table_add_changefeed is called when production alter_table_add_changefeed is exited. +func (s *BaseYQLListener) ExitAlter_table_add_changefeed(ctx *Alter_table_add_changefeedContext) {} + +// EnterAlter_table_alter_changefeed is called when production alter_table_alter_changefeed is entered. +func (s *BaseYQLListener) EnterAlter_table_alter_changefeed(ctx *Alter_table_alter_changefeedContext) {} + +// ExitAlter_table_alter_changefeed is called when production alter_table_alter_changefeed is exited. +func (s *BaseYQLListener) ExitAlter_table_alter_changefeed(ctx *Alter_table_alter_changefeedContext) {} + +// EnterAlter_table_drop_changefeed is called when production alter_table_drop_changefeed is entered. +func (s *BaseYQLListener) EnterAlter_table_drop_changefeed(ctx *Alter_table_drop_changefeedContext) {} + +// ExitAlter_table_drop_changefeed is called when production alter_table_drop_changefeed is exited. +func (s *BaseYQLListener) ExitAlter_table_drop_changefeed(ctx *Alter_table_drop_changefeedContext) {} + +// EnterAlter_table_alter_index is called when production alter_table_alter_index is entered. +func (s *BaseYQLListener) EnterAlter_table_alter_index(ctx *Alter_table_alter_indexContext) {} + +// ExitAlter_table_alter_index is called when production alter_table_alter_index is exited. +func (s *BaseYQLListener) ExitAlter_table_alter_index(ctx *Alter_table_alter_indexContext) {} + +// EnterColumn_schema is called when production column_schema is entered. +func (s *BaseYQLListener) EnterColumn_schema(ctx *Column_schemaContext) {} + +// ExitColumn_schema is called when production column_schema is exited. +func (s *BaseYQLListener) ExitColumn_schema(ctx *Column_schemaContext) {} + +// EnterFamily_relation is called when production family_relation is entered. +func (s *BaseYQLListener) EnterFamily_relation(ctx *Family_relationContext) {} + +// ExitFamily_relation is called when production family_relation is exited. +func (s *BaseYQLListener) ExitFamily_relation(ctx *Family_relationContext) {} + +// EnterOpt_column_constraints is called when production opt_column_constraints is entered. +func (s *BaseYQLListener) EnterOpt_column_constraints(ctx *Opt_column_constraintsContext) {} + +// ExitOpt_column_constraints is called when production opt_column_constraints is exited. +func (s *BaseYQLListener) ExitOpt_column_constraints(ctx *Opt_column_constraintsContext) {} + +// EnterColumn_order_by_specification is called when production column_order_by_specification is entered. +func (s *BaseYQLListener) EnterColumn_order_by_specification(ctx *Column_order_by_specificationContext) {} + +// ExitColumn_order_by_specification is called when production column_order_by_specification is exited. +func (s *BaseYQLListener) ExitColumn_order_by_specification(ctx *Column_order_by_specificationContext) {} + +// EnterTable_constraint is called when production table_constraint is entered. +func (s *BaseYQLListener) EnterTable_constraint(ctx *Table_constraintContext) {} + +// ExitTable_constraint is called when production table_constraint is exited. +func (s *BaseYQLListener) ExitTable_constraint(ctx *Table_constraintContext) {} + +// EnterTable_index is called when production table_index is entered. +func (s *BaseYQLListener) EnterTable_index(ctx *Table_indexContext) {} + +// ExitTable_index is called when production table_index is exited. +func (s *BaseYQLListener) ExitTable_index(ctx *Table_indexContext) {} + +// EnterTable_index_type is called when production table_index_type is entered. +func (s *BaseYQLListener) EnterTable_index_type(ctx *Table_index_typeContext) {} + +// ExitTable_index_type is called when production table_index_type is exited. +func (s *BaseYQLListener) ExitTable_index_type(ctx *Table_index_typeContext) {} + +// EnterGlobal_index is called when production global_index is entered. +func (s *BaseYQLListener) EnterGlobal_index(ctx *Global_indexContext) {} + +// ExitGlobal_index is called when production global_index is exited. +func (s *BaseYQLListener) ExitGlobal_index(ctx *Global_indexContext) {} + +// EnterLocal_index is called when production local_index is entered. +func (s *BaseYQLListener) EnterLocal_index(ctx *Local_indexContext) {} + +// ExitLocal_index is called when production local_index is exited. +func (s *BaseYQLListener) ExitLocal_index(ctx *Local_indexContext) {} + +// EnterIndex_subtype is called when production index_subtype is entered. +func (s *BaseYQLListener) EnterIndex_subtype(ctx *Index_subtypeContext) {} + +// ExitIndex_subtype is called when production index_subtype is exited. +func (s *BaseYQLListener) ExitIndex_subtype(ctx *Index_subtypeContext) {} + +// EnterWith_index_settings is called when production with_index_settings is entered. +func (s *BaseYQLListener) EnterWith_index_settings(ctx *With_index_settingsContext) {} + +// ExitWith_index_settings is called when production with_index_settings is exited. +func (s *BaseYQLListener) ExitWith_index_settings(ctx *With_index_settingsContext) {} + +// EnterIndex_setting_entry is called when production index_setting_entry is entered. +func (s *BaseYQLListener) EnterIndex_setting_entry(ctx *Index_setting_entryContext) {} + +// ExitIndex_setting_entry is called when production index_setting_entry is exited. +func (s *BaseYQLListener) ExitIndex_setting_entry(ctx *Index_setting_entryContext) {} + +// EnterIndex_setting_value is called when production index_setting_value is entered. +func (s *BaseYQLListener) EnterIndex_setting_value(ctx *Index_setting_valueContext) {} + +// ExitIndex_setting_value is called when production index_setting_value is exited. +func (s *BaseYQLListener) ExitIndex_setting_value(ctx *Index_setting_valueContext) {} + +// EnterChangefeed is called when production changefeed is entered. +func (s *BaseYQLListener) EnterChangefeed(ctx *ChangefeedContext) {} + +// ExitChangefeed is called when production changefeed is exited. +func (s *BaseYQLListener) ExitChangefeed(ctx *ChangefeedContext) {} + +// EnterChangefeed_settings is called when production changefeed_settings is entered. +func (s *BaseYQLListener) EnterChangefeed_settings(ctx *Changefeed_settingsContext) {} + +// ExitChangefeed_settings is called when production changefeed_settings is exited. +func (s *BaseYQLListener) ExitChangefeed_settings(ctx *Changefeed_settingsContext) {} + +// EnterChangefeed_settings_entry is called when production changefeed_settings_entry is entered. +func (s *BaseYQLListener) EnterChangefeed_settings_entry(ctx *Changefeed_settings_entryContext) {} + +// ExitChangefeed_settings_entry is called when production changefeed_settings_entry is exited. +func (s *BaseYQLListener) ExitChangefeed_settings_entry(ctx *Changefeed_settings_entryContext) {} + +// EnterChangefeed_setting_value is called when production changefeed_setting_value is entered. +func (s *BaseYQLListener) EnterChangefeed_setting_value(ctx *Changefeed_setting_valueContext) {} + +// ExitChangefeed_setting_value is called when production changefeed_setting_value is exited. +func (s *BaseYQLListener) ExitChangefeed_setting_value(ctx *Changefeed_setting_valueContext) {} + +// EnterChangefeed_alter_settings is called when production changefeed_alter_settings is entered. +func (s *BaseYQLListener) EnterChangefeed_alter_settings(ctx *Changefeed_alter_settingsContext) {} + +// ExitChangefeed_alter_settings is called when production changefeed_alter_settings is exited. +func (s *BaseYQLListener) ExitChangefeed_alter_settings(ctx *Changefeed_alter_settingsContext) {} + +// EnterAlter_table_setting_entry is called when production alter_table_setting_entry is entered. +func (s *BaseYQLListener) EnterAlter_table_setting_entry(ctx *Alter_table_setting_entryContext) {} + +// ExitAlter_table_setting_entry is called when production alter_table_setting_entry is exited. +func (s *BaseYQLListener) ExitAlter_table_setting_entry(ctx *Alter_table_setting_entryContext) {} + +// EnterTable_setting_value is called when production table_setting_value is entered. +func (s *BaseYQLListener) EnterTable_setting_value(ctx *Table_setting_valueContext) {} + +// ExitTable_setting_value is called when production table_setting_value is exited. +func (s *BaseYQLListener) ExitTable_setting_value(ctx *Table_setting_valueContext) {} + +// EnterTtl_tier_list is called when production ttl_tier_list is entered. +func (s *BaseYQLListener) EnterTtl_tier_list(ctx *Ttl_tier_listContext) {} + +// ExitTtl_tier_list is called when production ttl_tier_list is exited. +func (s *BaseYQLListener) ExitTtl_tier_list(ctx *Ttl_tier_listContext) {} + +// EnterTtl_tier_action is called when production ttl_tier_action is entered. +func (s *BaseYQLListener) EnterTtl_tier_action(ctx *Ttl_tier_actionContext) {} + +// ExitTtl_tier_action is called when production ttl_tier_action is exited. +func (s *BaseYQLListener) ExitTtl_tier_action(ctx *Ttl_tier_actionContext) {} + +// EnterFamily_entry is called when production family_entry is entered. +func (s *BaseYQLListener) EnterFamily_entry(ctx *Family_entryContext) {} + +// ExitFamily_entry is called when production family_entry is exited. +func (s *BaseYQLListener) ExitFamily_entry(ctx *Family_entryContext) {} + +// EnterFamily_settings is called when production family_settings is entered. +func (s *BaseYQLListener) EnterFamily_settings(ctx *Family_settingsContext) {} + +// ExitFamily_settings is called when production family_settings is exited. +func (s *BaseYQLListener) ExitFamily_settings(ctx *Family_settingsContext) {} + +// EnterFamily_settings_entry is called when production family_settings_entry is entered. +func (s *BaseYQLListener) EnterFamily_settings_entry(ctx *Family_settings_entryContext) {} + +// ExitFamily_settings_entry is called when production family_settings_entry is exited. +func (s *BaseYQLListener) ExitFamily_settings_entry(ctx *Family_settings_entryContext) {} + +// EnterFamily_setting_value is called when production family_setting_value is entered. +func (s *BaseYQLListener) EnterFamily_setting_value(ctx *Family_setting_valueContext) {} + +// ExitFamily_setting_value is called when production family_setting_value is exited. +func (s *BaseYQLListener) ExitFamily_setting_value(ctx *Family_setting_valueContext) {} + +// EnterSplit_boundaries is called when production split_boundaries is entered. +func (s *BaseYQLListener) EnterSplit_boundaries(ctx *Split_boundariesContext) {} + +// ExitSplit_boundaries is called when production split_boundaries is exited. +func (s *BaseYQLListener) ExitSplit_boundaries(ctx *Split_boundariesContext) {} + +// EnterLiteral_value_list is called when production literal_value_list is entered. +func (s *BaseYQLListener) EnterLiteral_value_list(ctx *Literal_value_listContext) {} + +// ExitLiteral_value_list is called when production literal_value_list is exited. +func (s *BaseYQLListener) ExitLiteral_value_list(ctx *Literal_value_listContext) {} + +// EnterAlter_table_alter_index_action is called when production alter_table_alter_index_action is entered. +func (s *BaseYQLListener) EnterAlter_table_alter_index_action(ctx *Alter_table_alter_index_actionContext) {} + +// ExitAlter_table_alter_index_action is called when production alter_table_alter_index_action is exited. +func (s *BaseYQLListener) ExitAlter_table_alter_index_action(ctx *Alter_table_alter_index_actionContext) {} + +// EnterDrop_table_stmt is called when production drop_table_stmt is entered. +func (s *BaseYQLListener) EnterDrop_table_stmt(ctx *Drop_table_stmtContext) {} + +// ExitDrop_table_stmt is called when production drop_table_stmt is exited. +func (s *BaseYQLListener) ExitDrop_table_stmt(ctx *Drop_table_stmtContext) {} + +// EnterCreate_user_stmt is called when production create_user_stmt is entered. +func (s *BaseYQLListener) EnterCreate_user_stmt(ctx *Create_user_stmtContext) {} + +// ExitCreate_user_stmt is called when production create_user_stmt is exited. +func (s *BaseYQLListener) ExitCreate_user_stmt(ctx *Create_user_stmtContext) {} + +// EnterAlter_user_stmt is called when production alter_user_stmt is entered. +func (s *BaseYQLListener) EnterAlter_user_stmt(ctx *Alter_user_stmtContext) {} + +// ExitAlter_user_stmt is called when production alter_user_stmt is exited. +func (s *BaseYQLListener) ExitAlter_user_stmt(ctx *Alter_user_stmtContext) {} + +// EnterCreate_group_stmt is called when production create_group_stmt is entered. +func (s *BaseYQLListener) EnterCreate_group_stmt(ctx *Create_group_stmtContext) {} + +// ExitCreate_group_stmt is called when production create_group_stmt is exited. +func (s *BaseYQLListener) ExitCreate_group_stmt(ctx *Create_group_stmtContext) {} + +// EnterAlter_group_stmt is called when production alter_group_stmt is entered. +func (s *BaseYQLListener) EnterAlter_group_stmt(ctx *Alter_group_stmtContext) {} + +// ExitAlter_group_stmt is called when production alter_group_stmt is exited. +func (s *BaseYQLListener) ExitAlter_group_stmt(ctx *Alter_group_stmtContext) {} + +// EnterDrop_role_stmt is called when production drop_role_stmt is entered. +func (s *BaseYQLListener) EnterDrop_role_stmt(ctx *Drop_role_stmtContext) {} + +// ExitDrop_role_stmt is called when production drop_role_stmt is exited. +func (s *BaseYQLListener) ExitDrop_role_stmt(ctx *Drop_role_stmtContext) {} + +// EnterRole_name is called when production role_name is entered. +func (s *BaseYQLListener) EnterRole_name(ctx *Role_nameContext) {} + +// ExitRole_name is called when production role_name is exited. +func (s *BaseYQLListener) ExitRole_name(ctx *Role_nameContext) {} + +// EnterCreate_user_option is called when production create_user_option is entered. +func (s *BaseYQLListener) EnterCreate_user_option(ctx *Create_user_optionContext) {} + +// ExitCreate_user_option is called when production create_user_option is exited. +func (s *BaseYQLListener) ExitCreate_user_option(ctx *Create_user_optionContext) {} + +// EnterPassword_option is called when production password_option is entered. +func (s *BaseYQLListener) EnterPassword_option(ctx *Password_optionContext) {} + +// ExitPassword_option is called when production password_option is exited. +func (s *BaseYQLListener) ExitPassword_option(ctx *Password_optionContext) {} + +// EnterLogin_option is called when production login_option is entered. +func (s *BaseYQLListener) EnterLogin_option(ctx *Login_optionContext) {} + +// ExitLogin_option is called when production login_option is exited. +func (s *BaseYQLListener) ExitLogin_option(ctx *Login_optionContext) {} + +// EnterGrant_permissions_stmt is called when production grant_permissions_stmt is entered. +func (s *BaseYQLListener) EnterGrant_permissions_stmt(ctx *Grant_permissions_stmtContext) {} + +// ExitGrant_permissions_stmt is called when production grant_permissions_stmt is exited. +func (s *BaseYQLListener) ExitGrant_permissions_stmt(ctx *Grant_permissions_stmtContext) {} + +// EnterRevoke_permissions_stmt is called when production revoke_permissions_stmt is entered. +func (s *BaseYQLListener) EnterRevoke_permissions_stmt(ctx *Revoke_permissions_stmtContext) {} + +// ExitRevoke_permissions_stmt is called when production revoke_permissions_stmt is exited. +func (s *BaseYQLListener) ExitRevoke_permissions_stmt(ctx *Revoke_permissions_stmtContext) {} + +// EnterPermission_id is called when production permission_id is entered. +func (s *BaseYQLListener) EnterPermission_id(ctx *Permission_idContext) {} + +// ExitPermission_id is called when production permission_id is exited. +func (s *BaseYQLListener) ExitPermission_id(ctx *Permission_idContext) {} + +// EnterPermission_name is called when production permission_name is entered. +func (s *BaseYQLListener) EnterPermission_name(ctx *Permission_nameContext) {} + +// ExitPermission_name is called when production permission_name is exited. +func (s *BaseYQLListener) ExitPermission_name(ctx *Permission_nameContext) {} + +// EnterPermission_name_target is called when production permission_name_target is entered. +func (s *BaseYQLListener) EnterPermission_name_target(ctx *Permission_name_targetContext) {} + +// ExitPermission_name_target is called when production permission_name_target is exited. +func (s *BaseYQLListener) ExitPermission_name_target(ctx *Permission_name_targetContext) {} + +// EnterCreate_resource_pool_stmt is called when production create_resource_pool_stmt is entered. +func (s *BaseYQLListener) EnterCreate_resource_pool_stmt(ctx *Create_resource_pool_stmtContext) {} + +// ExitCreate_resource_pool_stmt is called when production create_resource_pool_stmt is exited. +func (s *BaseYQLListener) ExitCreate_resource_pool_stmt(ctx *Create_resource_pool_stmtContext) {} + +// EnterAlter_resource_pool_stmt is called when production alter_resource_pool_stmt is entered. +func (s *BaseYQLListener) EnterAlter_resource_pool_stmt(ctx *Alter_resource_pool_stmtContext) {} + +// ExitAlter_resource_pool_stmt is called when production alter_resource_pool_stmt is exited. +func (s *BaseYQLListener) ExitAlter_resource_pool_stmt(ctx *Alter_resource_pool_stmtContext) {} + +// EnterAlter_resource_pool_action is called when production alter_resource_pool_action is entered. +func (s *BaseYQLListener) EnterAlter_resource_pool_action(ctx *Alter_resource_pool_actionContext) {} + +// ExitAlter_resource_pool_action is called when production alter_resource_pool_action is exited. +func (s *BaseYQLListener) ExitAlter_resource_pool_action(ctx *Alter_resource_pool_actionContext) {} + +// EnterDrop_resource_pool_stmt is called when production drop_resource_pool_stmt is entered. +func (s *BaseYQLListener) EnterDrop_resource_pool_stmt(ctx *Drop_resource_pool_stmtContext) {} + +// ExitDrop_resource_pool_stmt is called when production drop_resource_pool_stmt is exited. +func (s *BaseYQLListener) ExitDrop_resource_pool_stmt(ctx *Drop_resource_pool_stmtContext) {} + +// EnterCreate_resource_pool_classifier_stmt is called when production create_resource_pool_classifier_stmt is entered. +func (s *BaseYQLListener) EnterCreate_resource_pool_classifier_stmt(ctx *Create_resource_pool_classifier_stmtContext) {} + +// ExitCreate_resource_pool_classifier_stmt is called when production create_resource_pool_classifier_stmt is exited. +func (s *BaseYQLListener) ExitCreate_resource_pool_classifier_stmt(ctx *Create_resource_pool_classifier_stmtContext) {} + +// EnterAlter_resource_pool_classifier_stmt is called when production alter_resource_pool_classifier_stmt is entered. +func (s *BaseYQLListener) EnterAlter_resource_pool_classifier_stmt(ctx *Alter_resource_pool_classifier_stmtContext) {} + +// ExitAlter_resource_pool_classifier_stmt is called when production alter_resource_pool_classifier_stmt is exited. +func (s *BaseYQLListener) ExitAlter_resource_pool_classifier_stmt(ctx *Alter_resource_pool_classifier_stmtContext) {} + +// EnterAlter_resource_pool_classifier_action is called when production alter_resource_pool_classifier_action is entered. +func (s *BaseYQLListener) EnterAlter_resource_pool_classifier_action(ctx *Alter_resource_pool_classifier_actionContext) {} + +// ExitAlter_resource_pool_classifier_action is called when production alter_resource_pool_classifier_action is exited. +func (s *BaseYQLListener) ExitAlter_resource_pool_classifier_action(ctx *Alter_resource_pool_classifier_actionContext) {} + +// EnterDrop_resource_pool_classifier_stmt is called when production drop_resource_pool_classifier_stmt is entered. +func (s *BaseYQLListener) EnterDrop_resource_pool_classifier_stmt(ctx *Drop_resource_pool_classifier_stmtContext) {} + +// ExitDrop_resource_pool_classifier_stmt is called when production drop_resource_pool_classifier_stmt is exited. +func (s *BaseYQLListener) ExitDrop_resource_pool_classifier_stmt(ctx *Drop_resource_pool_classifier_stmtContext) {} + +// EnterCreate_replication_stmt is called when production create_replication_stmt is entered. +func (s *BaseYQLListener) EnterCreate_replication_stmt(ctx *Create_replication_stmtContext) {} + +// ExitCreate_replication_stmt is called when production create_replication_stmt is exited. +func (s *BaseYQLListener) ExitCreate_replication_stmt(ctx *Create_replication_stmtContext) {} + +// EnterReplication_target is called when production replication_target is entered. +func (s *BaseYQLListener) EnterReplication_target(ctx *Replication_targetContext) {} + +// ExitReplication_target is called when production replication_target is exited. +func (s *BaseYQLListener) ExitReplication_target(ctx *Replication_targetContext) {} + +// EnterReplication_settings is called when production replication_settings is entered. +func (s *BaseYQLListener) EnterReplication_settings(ctx *Replication_settingsContext) {} + +// ExitReplication_settings is called when production replication_settings is exited. +func (s *BaseYQLListener) ExitReplication_settings(ctx *Replication_settingsContext) {} + +// EnterReplication_settings_entry is called when production replication_settings_entry is entered. +func (s *BaseYQLListener) EnterReplication_settings_entry(ctx *Replication_settings_entryContext) {} + +// ExitReplication_settings_entry is called when production replication_settings_entry is exited. +func (s *BaseYQLListener) ExitReplication_settings_entry(ctx *Replication_settings_entryContext) {} + +// EnterAlter_replication_stmt is called when production alter_replication_stmt is entered. +func (s *BaseYQLListener) EnterAlter_replication_stmt(ctx *Alter_replication_stmtContext) {} + +// ExitAlter_replication_stmt is called when production alter_replication_stmt is exited. +func (s *BaseYQLListener) ExitAlter_replication_stmt(ctx *Alter_replication_stmtContext) {} + +// EnterAlter_replication_action is called when production alter_replication_action is entered. +func (s *BaseYQLListener) EnterAlter_replication_action(ctx *Alter_replication_actionContext) {} + +// ExitAlter_replication_action is called when production alter_replication_action is exited. +func (s *BaseYQLListener) ExitAlter_replication_action(ctx *Alter_replication_actionContext) {} + +// EnterAlter_replication_set_setting is called when production alter_replication_set_setting is entered. +func (s *BaseYQLListener) EnterAlter_replication_set_setting(ctx *Alter_replication_set_settingContext) {} + +// ExitAlter_replication_set_setting is called when production alter_replication_set_setting is exited. +func (s *BaseYQLListener) ExitAlter_replication_set_setting(ctx *Alter_replication_set_settingContext) {} + +// EnterDrop_replication_stmt is called when production drop_replication_stmt is entered. +func (s *BaseYQLListener) EnterDrop_replication_stmt(ctx *Drop_replication_stmtContext) {} + +// ExitDrop_replication_stmt is called when production drop_replication_stmt is exited. +func (s *BaseYQLListener) ExitDrop_replication_stmt(ctx *Drop_replication_stmtContext) {} + +// EnterAction_or_subquery_args is called when production action_or_subquery_args is entered. +func (s *BaseYQLListener) EnterAction_or_subquery_args(ctx *Action_or_subquery_argsContext) {} + +// ExitAction_or_subquery_args is called when production action_or_subquery_args is exited. +func (s *BaseYQLListener) ExitAction_or_subquery_args(ctx *Action_or_subquery_argsContext) {} + +// EnterDefine_action_or_subquery_stmt is called when production define_action_or_subquery_stmt is entered. +func (s *BaseYQLListener) EnterDefine_action_or_subquery_stmt(ctx *Define_action_or_subquery_stmtContext) {} + +// ExitDefine_action_or_subquery_stmt is called when production define_action_or_subquery_stmt is exited. +func (s *BaseYQLListener) ExitDefine_action_or_subquery_stmt(ctx *Define_action_or_subquery_stmtContext) {} + +// EnterDefine_action_or_subquery_body is called when production define_action_or_subquery_body is entered. +func (s *BaseYQLListener) EnterDefine_action_or_subquery_body(ctx *Define_action_or_subquery_bodyContext) {} + +// ExitDefine_action_or_subquery_body is called when production define_action_or_subquery_body is exited. +func (s *BaseYQLListener) ExitDefine_action_or_subquery_body(ctx *Define_action_or_subquery_bodyContext) {} + +// EnterIf_stmt is called when production if_stmt is entered. +func (s *BaseYQLListener) EnterIf_stmt(ctx *If_stmtContext) {} + +// ExitIf_stmt is called when production if_stmt is exited. +func (s *BaseYQLListener) ExitIf_stmt(ctx *If_stmtContext) {} + +// EnterFor_stmt is called when production for_stmt is entered. +func (s *BaseYQLListener) EnterFor_stmt(ctx *For_stmtContext) {} + +// ExitFor_stmt is called when production for_stmt is exited. +func (s *BaseYQLListener) ExitFor_stmt(ctx *For_stmtContext) {} + +// EnterTable_ref is called when production table_ref is entered. +func (s *BaseYQLListener) EnterTable_ref(ctx *Table_refContext) {} + +// ExitTable_ref is called when production table_ref is exited. +func (s *BaseYQLListener) ExitTable_ref(ctx *Table_refContext) {} + +// EnterTable_key is called when production table_key is entered. +func (s *BaseYQLListener) EnterTable_key(ctx *Table_keyContext) {} + +// ExitTable_key is called when production table_key is exited. +func (s *BaseYQLListener) ExitTable_key(ctx *Table_keyContext) {} + +// EnterTable_arg is called when production table_arg is entered. +func (s *BaseYQLListener) EnterTable_arg(ctx *Table_argContext) {} + +// ExitTable_arg is called when production table_arg is exited. +func (s *BaseYQLListener) ExitTable_arg(ctx *Table_argContext) {} + +// EnterTable_hints is called when production table_hints is entered. +func (s *BaseYQLListener) EnterTable_hints(ctx *Table_hintsContext) {} + +// ExitTable_hints is called when production table_hints is exited. +func (s *BaseYQLListener) ExitTable_hints(ctx *Table_hintsContext) {} + +// EnterTable_hint is called when production table_hint is entered. +func (s *BaseYQLListener) EnterTable_hint(ctx *Table_hintContext) {} + +// ExitTable_hint is called when production table_hint is exited. +func (s *BaseYQLListener) ExitTable_hint(ctx *Table_hintContext) {} + +// EnterObject_ref is called when production object_ref is entered. +func (s *BaseYQLListener) EnterObject_ref(ctx *Object_refContext) {} + +// ExitObject_ref is called when production object_ref is exited. +func (s *BaseYQLListener) ExitObject_ref(ctx *Object_refContext) {} + +// EnterSimple_table_ref_core is called when production simple_table_ref_core is entered. +func (s *BaseYQLListener) EnterSimple_table_ref_core(ctx *Simple_table_ref_coreContext) {} + +// ExitSimple_table_ref_core is called when production simple_table_ref_core is exited. +func (s *BaseYQLListener) ExitSimple_table_ref_core(ctx *Simple_table_ref_coreContext) {} + +// EnterSimple_table_ref is called when production simple_table_ref is entered. +func (s *BaseYQLListener) EnterSimple_table_ref(ctx *Simple_table_refContext) {} + +// ExitSimple_table_ref is called when production simple_table_ref is exited. +func (s *BaseYQLListener) ExitSimple_table_ref(ctx *Simple_table_refContext) {} + +// EnterInto_simple_table_ref is called when production into_simple_table_ref is entered. +func (s *BaseYQLListener) EnterInto_simple_table_ref(ctx *Into_simple_table_refContext) {} + +// ExitInto_simple_table_ref is called when production into_simple_table_ref is exited. +func (s *BaseYQLListener) ExitInto_simple_table_ref(ctx *Into_simple_table_refContext) {} + +// EnterDelete_stmt is called when production delete_stmt is entered. +func (s *BaseYQLListener) EnterDelete_stmt(ctx *Delete_stmtContext) {} + +// ExitDelete_stmt is called when production delete_stmt is exited. +func (s *BaseYQLListener) ExitDelete_stmt(ctx *Delete_stmtContext) {} + +// EnterUpdate_stmt is called when production update_stmt is entered. +func (s *BaseYQLListener) EnterUpdate_stmt(ctx *Update_stmtContext) {} + +// ExitUpdate_stmt is called when production update_stmt is exited. +func (s *BaseYQLListener) ExitUpdate_stmt(ctx *Update_stmtContext) {} + +// EnterSet_clause_choice is called when production set_clause_choice is entered. +func (s *BaseYQLListener) EnterSet_clause_choice(ctx *Set_clause_choiceContext) {} + +// ExitSet_clause_choice is called when production set_clause_choice is exited. +func (s *BaseYQLListener) ExitSet_clause_choice(ctx *Set_clause_choiceContext) {} + +// EnterSet_clause_list is called when production set_clause_list is entered. +func (s *BaseYQLListener) EnterSet_clause_list(ctx *Set_clause_listContext) {} + +// ExitSet_clause_list is called when production set_clause_list is exited. +func (s *BaseYQLListener) ExitSet_clause_list(ctx *Set_clause_listContext) {} + +// EnterSet_clause is called when production set_clause is entered. +func (s *BaseYQLListener) EnterSet_clause(ctx *Set_clauseContext) {} + +// ExitSet_clause is called when production set_clause is exited. +func (s *BaseYQLListener) ExitSet_clause(ctx *Set_clauseContext) {} + +// EnterSet_target is called when production set_target is entered. +func (s *BaseYQLListener) EnterSet_target(ctx *Set_targetContext) {} + +// ExitSet_target is called when production set_target is exited. +func (s *BaseYQLListener) ExitSet_target(ctx *Set_targetContext) {} + +// EnterMultiple_column_assignment is called when production multiple_column_assignment is entered. +func (s *BaseYQLListener) EnterMultiple_column_assignment(ctx *Multiple_column_assignmentContext) {} + +// ExitMultiple_column_assignment is called when production multiple_column_assignment is exited. +func (s *BaseYQLListener) ExitMultiple_column_assignment(ctx *Multiple_column_assignmentContext) {} + +// EnterSet_target_list is called when production set_target_list is entered. +func (s *BaseYQLListener) EnterSet_target_list(ctx *Set_target_listContext) {} + +// ExitSet_target_list is called when production set_target_list is exited. +func (s *BaseYQLListener) ExitSet_target_list(ctx *Set_target_listContext) {} + +// EnterCreate_topic_stmt is called when production create_topic_stmt is entered. +func (s *BaseYQLListener) EnterCreate_topic_stmt(ctx *Create_topic_stmtContext) {} + +// ExitCreate_topic_stmt is called when production create_topic_stmt is exited. +func (s *BaseYQLListener) ExitCreate_topic_stmt(ctx *Create_topic_stmtContext) {} + +// EnterCreate_topic_entries is called when production create_topic_entries is entered. +func (s *BaseYQLListener) EnterCreate_topic_entries(ctx *Create_topic_entriesContext) {} + +// ExitCreate_topic_entries is called when production create_topic_entries is exited. +func (s *BaseYQLListener) ExitCreate_topic_entries(ctx *Create_topic_entriesContext) {} + +// EnterCreate_topic_entry is called when production create_topic_entry is entered. +func (s *BaseYQLListener) EnterCreate_topic_entry(ctx *Create_topic_entryContext) {} + +// ExitCreate_topic_entry is called when production create_topic_entry is exited. +func (s *BaseYQLListener) ExitCreate_topic_entry(ctx *Create_topic_entryContext) {} + +// EnterWith_topic_settings is called when production with_topic_settings is entered. +func (s *BaseYQLListener) EnterWith_topic_settings(ctx *With_topic_settingsContext) {} + +// ExitWith_topic_settings is called when production with_topic_settings is exited. +func (s *BaseYQLListener) ExitWith_topic_settings(ctx *With_topic_settingsContext) {} + +// EnterAlter_topic_stmt is called when production alter_topic_stmt is entered. +func (s *BaseYQLListener) EnterAlter_topic_stmt(ctx *Alter_topic_stmtContext) {} + +// ExitAlter_topic_stmt is called when production alter_topic_stmt is exited. +func (s *BaseYQLListener) ExitAlter_topic_stmt(ctx *Alter_topic_stmtContext) {} + +// EnterAlter_topic_action is called when production alter_topic_action is entered. +func (s *BaseYQLListener) EnterAlter_topic_action(ctx *Alter_topic_actionContext) {} + +// ExitAlter_topic_action is called when production alter_topic_action is exited. +func (s *BaseYQLListener) ExitAlter_topic_action(ctx *Alter_topic_actionContext) {} + +// EnterAlter_topic_add_consumer is called when production alter_topic_add_consumer is entered. +func (s *BaseYQLListener) EnterAlter_topic_add_consumer(ctx *Alter_topic_add_consumerContext) {} + +// ExitAlter_topic_add_consumer is called when production alter_topic_add_consumer is exited. +func (s *BaseYQLListener) ExitAlter_topic_add_consumer(ctx *Alter_topic_add_consumerContext) {} + +// EnterTopic_create_consumer_entry is called when production topic_create_consumer_entry is entered. +func (s *BaseYQLListener) EnterTopic_create_consumer_entry(ctx *Topic_create_consumer_entryContext) {} + +// ExitTopic_create_consumer_entry is called when production topic_create_consumer_entry is exited. +func (s *BaseYQLListener) ExitTopic_create_consumer_entry(ctx *Topic_create_consumer_entryContext) {} + +// EnterAlter_topic_alter_consumer is called when production alter_topic_alter_consumer is entered. +func (s *BaseYQLListener) EnterAlter_topic_alter_consumer(ctx *Alter_topic_alter_consumerContext) {} + +// ExitAlter_topic_alter_consumer is called when production alter_topic_alter_consumer is exited. +func (s *BaseYQLListener) ExitAlter_topic_alter_consumer(ctx *Alter_topic_alter_consumerContext) {} + +// EnterAlter_topic_alter_consumer_entry is called when production alter_topic_alter_consumer_entry is entered. +func (s *BaseYQLListener) EnterAlter_topic_alter_consumer_entry(ctx *Alter_topic_alter_consumer_entryContext) {} + +// ExitAlter_topic_alter_consumer_entry is called when production alter_topic_alter_consumer_entry is exited. +func (s *BaseYQLListener) ExitAlter_topic_alter_consumer_entry(ctx *Alter_topic_alter_consumer_entryContext) {} + +// EnterAlter_topic_drop_consumer is called when production alter_topic_drop_consumer is entered. +func (s *BaseYQLListener) EnterAlter_topic_drop_consumer(ctx *Alter_topic_drop_consumerContext) {} + +// ExitAlter_topic_drop_consumer is called when production alter_topic_drop_consumer is exited. +func (s *BaseYQLListener) ExitAlter_topic_drop_consumer(ctx *Alter_topic_drop_consumerContext) {} + +// EnterTopic_alter_consumer_set is called when production topic_alter_consumer_set is entered. +func (s *BaseYQLListener) EnterTopic_alter_consumer_set(ctx *Topic_alter_consumer_setContext) {} + +// ExitTopic_alter_consumer_set is called when production topic_alter_consumer_set is exited. +func (s *BaseYQLListener) ExitTopic_alter_consumer_set(ctx *Topic_alter_consumer_setContext) {} + +// EnterTopic_alter_consumer_reset is called when production topic_alter_consumer_reset is entered. +func (s *BaseYQLListener) EnterTopic_alter_consumer_reset(ctx *Topic_alter_consumer_resetContext) {} + +// ExitTopic_alter_consumer_reset is called when production topic_alter_consumer_reset is exited. +func (s *BaseYQLListener) ExitTopic_alter_consumer_reset(ctx *Topic_alter_consumer_resetContext) {} + +// EnterAlter_topic_set_settings is called when production alter_topic_set_settings is entered. +func (s *BaseYQLListener) EnterAlter_topic_set_settings(ctx *Alter_topic_set_settingsContext) {} + +// ExitAlter_topic_set_settings is called when production alter_topic_set_settings is exited. +func (s *BaseYQLListener) ExitAlter_topic_set_settings(ctx *Alter_topic_set_settingsContext) {} + +// EnterAlter_topic_reset_settings is called when production alter_topic_reset_settings is entered. +func (s *BaseYQLListener) EnterAlter_topic_reset_settings(ctx *Alter_topic_reset_settingsContext) {} + +// ExitAlter_topic_reset_settings is called when production alter_topic_reset_settings is exited. +func (s *BaseYQLListener) ExitAlter_topic_reset_settings(ctx *Alter_topic_reset_settingsContext) {} + +// EnterDrop_topic_stmt is called when production drop_topic_stmt is entered. +func (s *BaseYQLListener) EnterDrop_topic_stmt(ctx *Drop_topic_stmtContext) {} + +// ExitDrop_topic_stmt is called when production drop_topic_stmt is exited. +func (s *BaseYQLListener) ExitDrop_topic_stmt(ctx *Drop_topic_stmtContext) {} + +// EnterTopic_settings is called when production topic_settings is entered. +func (s *BaseYQLListener) EnterTopic_settings(ctx *Topic_settingsContext) {} + +// ExitTopic_settings is called when production topic_settings is exited. +func (s *BaseYQLListener) ExitTopic_settings(ctx *Topic_settingsContext) {} + +// EnterTopic_settings_entry is called when production topic_settings_entry is entered. +func (s *BaseYQLListener) EnterTopic_settings_entry(ctx *Topic_settings_entryContext) {} + +// ExitTopic_settings_entry is called when production topic_settings_entry is exited. +func (s *BaseYQLListener) ExitTopic_settings_entry(ctx *Topic_settings_entryContext) {} + +// EnterTopic_setting_value is called when production topic_setting_value is entered. +func (s *BaseYQLListener) EnterTopic_setting_value(ctx *Topic_setting_valueContext) {} + +// ExitTopic_setting_value is called when production topic_setting_value is exited. +func (s *BaseYQLListener) ExitTopic_setting_value(ctx *Topic_setting_valueContext) {} + +// EnterTopic_consumer_with_settings is called when production topic_consumer_with_settings is entered. +func (s *BaseYQLListener) EnterTopic_consumer_with_settings(ctx *Topic_consumer_with_settingsContext) {} + +// ExitTopic_consumer_with_settings is called when production topic_consumer_with_settings is exited. +func (s *BaseYQLListener) ExitTopic_consumer_with_settings(ctx *Topic_consumer_with_settingsContext) {} + +// EnterTopic_consumer_settings is called when production topic_consumer_settings is entered. +func (s *BaseYQLListener) EnterTopic_consumer_settings(ctx *Topic_consumer_settingsContext) {} + +// ExitTopic_consumer_settings is called when production topic_consumer_settings is exited. +func (s *BaseYQLListener) ExitTopic_consumer_settings(ctx *Topic_consumer_settingsContext) {} + +// EnterTopic_consumer_settings_entry is called when production topic_consumer_settings_entry is entered. +func (s *BaseYQLListener) EnterTopic_consumer_settings_entry(ctx *Topic_consumer_settings_entryContext) {} + +// ExitTopic_consumer_settings_entry is called when production topic_consumer_settings_entry is exited. +func (s *BaseYQLListener) ExitTopic_consumer_settings_entry(ctx *Topic_consumer_settings_entryContext) {} + +// EnterTopic_consumer_setting_value is called when production topic_consumer_setting_value is entered. +func (s *BaseYQLListener) EnterTopic_consumer_setting_value(ctx *Topic_consumer_setting_valueContext) {} + +// ExitTopic_consumer_setting_value is called when production topic_consumer_setting_value is exited. +func (s *BaseYQLListener) ExitTopic_consumer_setting_value(ctx *Topic_consumer_setting_valueContext) {} + +// EnterTopic_ref is called when production topic_ref is entered. +func (s *BaseYQLListener) EnterTopic_ref(ctx *Topic_refContext) {} + +// ExitTopic_ref is called when production topic_ref is exited. +func (s *BaseYQLListener) ExitTopic_ref(ctx *Topic_refContext) {} + +// EnterTopic_consumer_ref is called when production topic_consumer_ref is entered. +func (s *BaseYQLListener) EnterTopic_consumer_ref(ctx *Topic_consumer_refContext) {} + +// ExitTopic_consumer_ref is called when production topic_consumer_ref is exited. +func (s *BaseYQLListener) ExitTopic_consumer_ref(ctx *Topic_consumer_refContext) {} + +// EnterNull_treatment is called when production null_treatment is entered. +func (s *BaseYQLListener) EnterNull_treatment(ctx *Null_treatmentContext) {} + +// ExitNull_treatment is called when production null_treatment is exited. +func (s *BaseYQLListener) ExitNull_treatment(ctx *Null_treatmentContext) {} + +// EnterFilter_clause is called when production filter_clause is entered. +func (s *BaseYQLListener) EnterFilter_clause(ctx *Filter_clauseContext) {} + +// ExitFilter_clause is called when production filter_clause is exited. +func (s *BaseYQLListener) ExitFilter_clause(ctx *Filter_clauseContext) {} + +// EnterWindow_name_or_specification is called when production window_name_or_specification is entered. +func (s *BaseYQLListener) EnterWindow_name_or_specification(ctx *Window_name_or_specificationContext) {} + +// ExitWindow_name_or_specification is called when production window_name_or_specification is exited. +func (s *BaseYQLListener) ExitWindow_name_or_specification(ctx *Window_name_or_specificationContext) {} + +// EnterWindow_name is called when production window_name is entered. +func (s *BaseYQLListener) EnterWindow_name(ctx *Window_nameContext) {} + +// ExitWindow_name is called when production window_name is exited. +func (s *BaseYQLListener) ExitWindow_name(ctx *Window_nameContext) {} + +// EnterWindow_clause is called when production window_clause is entered. +func (s *BaseYQLListener) EnterWindow_clause(ctx *Window_clauseContext) {} + +// ExitWindow_clause is called when production window_clause is exited. +func (s *BaseYQLListener) ExitWindow_clause(ctx *Window_clauseContext) {} + +// EnterWindow_definition_list is called when production window_definition_list is entered. +func (s *BaseYQLListener) EnterWindow_definition_list(ctx *Window_definition_listContext) {} + +// ExitWindow_definition_list is called when production window_definition_list is exited. +func (s *BaseYQLListener) ExitWindow_definition_list(ctx *Window_definition_listContext) {} + +// EnterWindow_definition is called when production window_definition is entered. +func (s *BaseYQLListener) EnterWindow_definition(ctx *Window_definitionContext) {} + +// ExitWindow_definition is called when production window_definition is exited. +func (s *BaseYQLListener) ExitWindow_definition(ctx *Window_definitionContext) {} + +// EnterNew_window_name is called when production new_window_name is entered. +func (s *BaseYQLListener) EnterNew_window_name(ctx *New_window_nameContext) {} + +// ExitNew_window_name is called when production new_window_name is exited. +func (s *BaseYQLListener) ExitNew_window_name(ctx *New_window_nameContext) {} + +// EnterWindow_specification is called when production window_specification is entered. +func (s *BaseYQLListener) EnterWindow_specification(ctx *Window_specificationContext) {} + +// ExitWindow_specification is called when production window_specification is exited. +func (s *BaseYQLListener) ExitWindow_specification(ctx *Window_specificationContext) {} + +// EnterWindow_specification_details is called when production window_specification_details is entered. +func (s *BaseYQLListener) EnterWindow_specification_details(ctx *Window_specification_detailsContext) {} + +// ExitWindow_specification_details is called when production window_specification_details is exited. +func (s *BaseYQLListener) ExitWindow_specification_details(ctx *Window_specification_detailsContext) {} + +// EnterExisting_window_name is called when production existing_window_name is entered. +func (s *BaseYQLListener) EnterExisting_window_name(ctx *Existing_window_nameContext) {} + +// ExitExisting_window_name is called when production existing_window_name is exited. +func (s *BaseYQLListener) ExitExisting_window_name(ctx *Existing_window_nameContext) {} + +// EnterWindow_partition_clause is called when production window_partition_clause is entered. +func (s *BaseYQLListener) EnterWindow_partition_clause(ctx *Window_partition_clauseContext) {} + +// ExitWindow_partition_clause is called when production window_partition_clause is exited. +func (s *BaseYQLListener) ExitWindow_partition_clause(ctx *Window_partition_clauseContext) {} + +// EnterWindow_order_clause is called when production window_order_clause is entered. +func (s *BaseYQLListener) EnterWindow_order_clause(ctx *Window_order_clauseContext) {} + +// ExitWindow_order_clause is called when production window_order_clause is exited. +func (s *BaseYQLListener) ExitWindow_order_clause(ctx *Window_order_clauseContext) {} + +// EnterWindow_frame_clause is called when production window_frame_clause is entered. +func (s *BaseYQLListener) EnterWindow_frame_clause(ctx *Window_frame_clauseContext) {} + +// ExitWindow_frame_clause is called when production window_frame_clause is exited. +func (s *BaseYQLListener) ExitWindow_frame_clause(ctx *Window_frame_clauseContext) {} + +// EnterWindow_frame_units is called when production window_frame_units is entered. +func (s *BaseYQLListener) EnterWindow_frame_units(ctx *Window_frame_unitsContext) {} + +// ExitWindow_frame_units is called when production window_frame_units is exited. +func (s *BaseYQLListener) ExitWindow_frame_units(ctx *Window_frame_unitsContext) {} + +// EnterWindow_frame_extent is called when production window_frame_extent is entered. +func (s *BaseYQLListener) EnterWindow_frame_extent(ctx *Window_frame_extentContext) {} + +// ExitWindow_frame_extent is called when production window_frame_extent is exited. +func (s *BaseYQLListener) ExitWindow_frame_extent(ctx *Window_frame_extentContext) {} + +// EnterWindow_frame_between is called when production window_frame_between is entered. +func (s *BaseYQLListener) EnterWindow_frame_between(ctx *Window_frame_betweenContext) {} + +// ExitWindow_frame_between is called when production window_frame_between is exited. +func (s *BaseYQLListener) ExitWindow_frame_between(ctx *Window_frame_betweenContext) {} + +// EnterWindow_frame_bound is called when production window_frame_bound is entered. +func (s *BaseYQLListener) EnterWindow_frame_bound(ctx *Window_frame_boundContext) {} + +// ExitWindow_frame_bound is called when production window_frame_bound is exited. +func (s *BaseYQLListener) ExitWindow_frame_bound(ctx *Window_frame_boundContext) {} + +// EnterWindow_frame_exclusion is called when production window_frame_exclusion is entered. +func (s *BaseYQLListener) EnterWindow_frame_exclusion(ctx *Window_frame_exclusionContext) {} + +// ExitWindow_frame_exclusion is called when production window_frame_exclusion is exited. +func (s *BaseYQLListener) ExitWindow_frame_exclusion(ctx *Window_frame_exclusionContext) {} + +// EnterUse_stmt is called when production use_stmt is entered. +func (s *BaseYQLListener) EnterUse_stmt(ctx *Use_stmtContext) {} + +// ExitUse_stmt is called when production use_stmt is exited. +func (s *BaseYQLListener) ExitUse_stmt(ctx *Use_stmtContext) {} + +// EnterSubselect_stmt is called when production subselect_stmt is entered. +func (s *BaseYQLListener) EnterSubselect_stmt(ctx *Subselect_stmtContext) {} + +// ExitSubselect_stmt is called when production subselect_stmt is exited. +func (s *BaseYQLListener) ExitSubselect_stmt(ctx *Subselect_stmtContext) {} + +// EnterNamed_nodes_stmt is called when production named_nodes_stmt is entered. +func (s *BaseYQLListener) EnterNamed_nodes_stmt(ctx *Named_nodes_stmtContext) {} + +// ExitNamed_nodes_stmt is called when production named_nodes_stmt is exited. +func (s *BaseYQLListener) ExitNamed_nodes_stmt(ctx *Named_nodes_stmtContext) {} + +// EnterCommit_stmt is called when production commit_stmt is entered. +func (s *BaseYQLListener) EnterCommit_stmt(ctx *Commit_stmtContext) {} + +// ExitCommit_stmt is called when production commit_stmt is exited. +func (s *BaseYQLListener) ExitCommit_stmt(ctx *Commit_stmtContext) {} + +// EnterRollback_stmt is called when production rollback_stmt is entered. +func (s *BaseYQLListener) EnterRollback_stmt(ctx *Rollback_stmtContext) {} + +// ExitRollback_stmt is called when production rollback_stmt is exited. +func (s *BaseYQLListener) ExitRollback_stmt(ctx *Rollback_stmtContext) {} + +// EnterAnalyze_table is called when production analyze_table is entered. +func (s *BaseYQLListener) EnterAnalyze_table(ctx *Analyze_tableContext) {} + +// ExitAnalyze_table is called when production analyze_table is exited. +func (s *BaseYQLListener) ExitAnalyze_table(ctx *Analyze_tableContext) {} + +// EnterAnalyze_table_list is called when production analyze_table_list is entered. +func (s *BaseYQLListener) EnterAnalyze_table_list(ctx *Analyze_table_listContext) {} + +// ExitAnalyze_table_list is called when production analyze_table_list is exited. +func (s *BaseYQLListener) ExitAnalyze_table_list(ctx *Analyze_table_listContext) {} + +// EnterAnalyze_stmt is called when production analyze_stmt is entered. +func (s *BaseYQLListener) EnterAnalyze_stmt(ctx *Analyze_stmtContext) {} + +// ExitAnalyze_stmt is called when production analyze_stmt is exited. +func (s *BaseYQLListener) ExitAnalyze_stmt(ctx *Analyze_stmtContext) {} + +// EnterAlter_sequence_stmt is called when production alter_sequence_stmt is entered. +func (s *BaseYQLListener) EnterAlter_sequence_stmt(ctx *Alter_sequence_stmtContext) {} + +// ExitAlter_sequence_stmt is called when production alter_sequence_stmt is exited. +func (s *BaseYQLListener) ExitAlter_sequence_stmt(ctx *Alter_sequence_stmtContext) {} + +// EnterAlter_sequence_action is called when production alter_sequence_action is entered. +func (s *BaseYQLListener) EnterAlter_sequence_action(ctx *Alter_sequence_actionContext) {} + +// ExitAlter_sequence_action is called when production alter_sequence_action is exited. +func (s *BaseYQLListener) ExitAlter_sequence_action(ctx *Alter_sequence_actionContext) {} + +// EnterIdentifier is called when production identifier is entered. +func (s *BaseYQLListener) EnterIdentifier(ctx *IdentifierContext) {} + +// ExitIdentifier is called when production identifier is exited. +func (s *BaseYQLListener) ExitIdentifier(ctx *IdentifierContext) {} + +// EnterId is called when production id is entered. +func (s *BaseYQLListener) EnterId(ctx *IdContext) {} + +// ExitId is called when production id is exited. +func (s *BaseYQLListener) ExitId(ctx *IdContext) {} + +// EnterId_schema is called when production id_schema is entered. +func (s *BaseYQLListener) EnterId_schema(ctx *Id_schemaContext) {} + +// ExitId_schema is called when production id_schema is exited. +func (s *BaseYQLListener) ExitId_schema(ctx *Id_schemaContext) {} + +// EnterId_expr is called when production id_expr is entered. +func (s *BaseYQLListener) EnterId_expr(ctx *Id_exprContext) {} + +// ExitId_expr is called when production id_expr is exited. +func (s *BaseYQLListener) ExitId_expr(ctx *Id_exprContext) {} + +// EnterId_expr_in is called when production id_expr_in is entered. +func (s *BaseYQLListener) EnterId_expr_in(ctx *Id_expr_inContext) {} + +// ExitId_expr_in is called when production id_expr_in is exited. +func (s *BaseYQLListener) ExitId_expr_in(ctx *Id_expr_inContext) {} + +// EnterId_window is called when production id_window is entered. +func (s *BaseYQLListener) EnterId_window(ctx *Id_windowContext) {} + +// ExitId_window is called when production id_window is exited. +func (s *BaseYQLListener) ExitId_window(ctx *Id_windowContext) {} + +// EnterId_table is called when production id_table is entered. +func (s *BaseYQLListener) EnterId_table(ctx *Id_tableContext) {} + +// ExitId_table is called when production id_table is exited. +func (s *BaseYQLListener) ExitId_table(ctx *Id_tableContext) {} + +// EnterId_without is called when production id_without is entered. +func (s *BaseYQLListener) EnterId_without(ctx *Id_withoutContext) {} + +// ExitId_without is called when production id_without is exited. +func (s *BaseYQLListener) ExitId_without(ctx *Id_withoutContext) {} + +// EnterId_hint is called when production id_hint is entered. +func (s *BaseYQLListener) EnterId_hint(ctx *Id_hintContext) {} + +// ExitId_hint is called when production id_hint is exited. +func (s *BaseYQLListener) ExitId_hint(ctx *Id_hintContext) {} + +// EnterId_as_compat is called when production id_as_compat is entered. +func (s *BaseYQLListener) EnterId_as_compat(ctx *Id_as_compatContext) {} + +// ExitId_as_compat is called when production id_as_compat is exited. +func (s *BaseYQLListener) ExitId_as_compat(ctx *Id_as_compatContext) {} + +// EnterAn_id is called when production an_id is entered. +func (s *BaseYQLListener) EnterAn_id(ctx *An_idContext) {} + +// ExitAn_id is called when production an_id is exited. +func (s *BaseYQLListener) ExitAn_id(ctx *An_idContext) {} + +// EnterAn_id_or_type is called when production an_id_or_type is entered. +func (s *BaseYQLListener) EnterAn_id_or_type(ctx *An_id_or_typeContext) {} + +// ExitAn_id_or_type is called when production an_id_or_type is exited. +func (s *BaseYQLListener) ExitAn_id_or_type(ctx *An_id_or_typeContext) {} + +// EnterAn_id_schema is called when production an_id_schema is entered. +func (s *BaseYQLListener) EnterAn_id_schema(ctx *An_id_schemaContext) {} + +// ExitAn_id_schema is called when production an_id_schema is exited. +func (s *BaseYQLListener) ExitAn_id_schema(ctx *An_id_schemaContext) {} + +// EnterAn_id_expr is called when production an_id_expr is entered. +func (s *BaseYQLListener) EnterAn_id_expr(ctx *An_id_exprContext) {} + +// ExitAn_id_expr is called when production an_id_expr is exited. +func (s *BaseYQLListener) ExitAn_id_expr(ctx *An_id_exprContext) {} + +// EnterAn_id_expr_in is called when production an_id_expr_in is entered. +func (s *BaseYQLListener) EnterAn_id_expr_in(ctx *An_id_expr_inContext) {} + +// ExitAn_id_expr_in is called when production an_id_expr_in is exited. +func (s *BaseYQLListener) ExitAn_id_expr_in(ctx *An_id_expr_inContext) {} + +// EnterAn_id_window is called when production an_id_window is entered. +func (s *BaseYQLListener) EnterAn_id_window(ctx *An_id_windowContext) {} + +// ExitAn_id_window is called when production an_id_window is exited. +func (s *BaseYQLListener) ExitAn_id_window(ctx *An_id_windowContext) {} + +// EnterAn_id_table is called when production an_id_table is entered. +func (s *BaseYQLListener) EnterAn_id_table(ctx *An_id_tableContext) {} + +// ExitAn_id_table is called when production an_id_table is exited. +func (s *BaseYQLListener) ExitAn_id_table(ctx *An_id_tableContext) {} + +// EnterAn_id_without is called when production an_id_without is entered. +func (s *BaseYQLListener) EnterAn_id_without(ctx *An_id_withoutContext) {} + +// ExitAn_id_without is called when production an_id_without is exited. +func (s *BaseYQLListener) ExitAn_id_without(ctx *An_id_withoutContext) {} + +// EnterAn_id_hint is called when production an_id_hint is entered. +func (s *BaseYQLListener) EnterAn_id_hint(ctx *An_id_hintContext) {} + +// ExitAn_id_hint is called when production an_id_hint is exited. +func (s *BaseYQLListener) ExitAn_id_hint(ctx *An_id_hintContext) {} + +// EnterAn_id_pure is called when production an_id_pure is entered. +func (s *BaseYQLListener) EnterAn_id_pure(ctx *An_id_pureContext) {} + +// ExitAn_id_pure is called when production an_id_pure is exited. +func (s *BaseYQLListener) ExitAn_id_pure(ctx *An_id_pureContext) {} + +// EnterAn_id_as_compat is called when production an_id_as_compat is entered. +func (s *BaseYQLListener) EnterAn_id_as_compat(ctx *An_id_as_compatContext) {} + +// ExitAn_id_as_compat is called when production an_id_as_compat is exited. +func (s *BaseYQLListener) ExitAn_id_as_compat(ctx *An_id_as_compatContext) {} + +// EnterView_name is called when production view_name is entered. +func (s *BaseYQLListener) EnterView_name(ctx *View_nameContext) {} + +// ExitView_name is called when production view_name is exited. +func (s *BaseYQLListener) ExitView_name(ctx *View_nameContext) {} + +// EnterOpt_id_prefix is called when production opt_id_prefix is entered. +func (s *BaseYQLListener) EnterOpt_id_prefix(ctx *Opt_id_prefixContext) {} + +// ExitOpt_id_prefix is called when production opt_id_prefix is exited. +func (s *BaseYQLListener) ExitOpt_id_prefix(ctx *Opt_id_prefixContext) {} + +// EnterCluster_expr is called when production cluster_expr is entered. +func (s *BaseYQLListener) EnterCluster_expr(ctx *Cluster_exprContext) {} + +// ExitCluster_expr is called when production cluster_expr is exited. +func (s *BaseYQLListener) ExitCluster_expr(ctx *Cluster_exprContext) {} + +// EnterId_or_type is called when production id_or_type is entered. +func (s *BaseYQLListener) EnterId_or_type(ctx *Id_or_typeContext) {} + +// ExitId_or_type is called when production id_or_type is exited. +func (s *BaseYQLListener) ExitId_or_type(ctx *Id_or_typeContext) {} + +// EnterOpt_id_prefix_or_type is called when production opt_id_prefix_or_type is entered. +func (s *BaseYQLListener) EnterOpt_id_prefix_or_type(ctx *Opt_id_prefix_or_typeContext) {} + +// ExitOpt_id_prefix_or_type is called when production opt_id_prefix_or_type is exited. +func (s *BaseYQLListener) ExitOpt_id_prefix_or_type(ctx *Opt_id_prefix_or_typeContext) {} + +// EnterId_or_at is called when production id_or_at is entered. +func (s *BaseYQLListener) EnterId_or_at(ctx *Id_or_atContext) {} + +// ExitId_or_at is called when production id_or_at is exited. +func (s *BaseYQLListener) ExitId_or_at(ctx *Id_or_atContext) {} + +// EnterId_table_or_type is called when production id_table_or_type is entered. +func (s *BaseYQLListener) EnterId_table_or_type(ctx *Id_table_or_typeContext) {} + +// ExitId_table_or_type is called when production id_table_or_type is exited. +func (s *BaseYQLListener) ExitId_table_or_type(ctx *Id_table_or_typeContext) {} + +// EnterId_table_or_at is called when production id_table_or_at is entered. +func (s *BaseYQLListener) EnterId_table_or_at(ctx *Id_table_or_atContext) {} + +// ExitId_table_or_at is called when production id_table_or_at is exited. +func (s *BaseYQLListener) ExitId_table_or_at(ctx *Id_table_or_atContext) {} + +// EnterKeyword is called when production keyword is entered. +func (s *BaseYQLListener) EnterKeyword(ctx *KeywordContext) {} + +// ExitKeyword is called when production keyword is exited. +func (s *BaseYQLListener) ExitKeyword(ctx *KeywordContext) {} + +// EnterKeyword_expr_uncompat is called when production keyword_expr_uncompat is entered. +func (s *BaseYQLListener) EnterKeyword_expr_uncompat(ctx *Keyword_expr_uncompatContext) {} + +// ExitKeyword_expr_uncompat is called when production keyword_expr_uncompat is exited. +func (s *BaseYQLListener) ExitKeyword_expr_uncompat(ctx *Keyword_expr_uncompatContext) {} + +// EnterKeyword_table_uncompat is called when production keyword_table_uncompat is entered. +func (s *BaseYQLListener) EnterKeyword_table_uncompat(ctx *Keyword_table_uncompatContext) {} + +// ExitKeyword_table_uncompat is called when production keyword_table_uncompat is exited. +func (s *BaseYQLListener) ExitKeyword_table_uncompat(ctx *Keyword_table_uncompatContext) {} + +// EnterKeyword_select_uncompat is called when production keyword_select_uncompat is entered. +func (s *BaseYQLListener) EnterKeyword_select_uncompat(ctx *Keyword_select_uncompatContext) {} + +// ExitKeyword_select_uncompat is called when production keyword_select_uncompat is exited. +func (s *BaseYQLListener) ExitKeyword_select_uncompat(ctx *Keyword_select_uncompatContext) {} + +// EnterKeyword_alter_uncompat is called when production keyword_alter_uncompat is entered. +func (s *BaseYQLListener) EnterKeyword_alter_uncompat(ctx *Keyword_alter_uncompatContext) {} + +// ExitKeyword_alter_uncompat is called when production keyword_alter_uncompat is exited. +func (s *BaseYQLListener) ExitKeyword_alter_uncompat(ctx *Keyword_alter_uncompatContext) {} + +// EnterKeyword_in_uncompat is called when production keyword_in_uncompat is entered. +func (s *BaseYQLListener) EnterKeyword_in_uncompat(ctx *Keyword_in_uncompatContext) {} + +// ExitKeyword_in_uncompat is called when production keyword_in_uncompat is exited. +func (s *BaseYQLListener) ExitKeyword_in_uncompat(ctx *Keyword_in_uncompatContext) {} + +// EnterKeyword_window_uncompat is called when production keyword_window_uncompat is entered. +func (s *BaseYQLListener) EnterKeyword_window_uncompat(ctx *Keyword_window_uncompatContext) {} + +// ExitKeyword_window_uncompat is called when production keyword_window_uncompat is exited. +func (s *BaseYQLListener) ExitKeyword_window_uncompat(ctx *Keyword_window_uncompatContext) {} + +// EnterKeyword_hint_uncompat is called when production keyword_hint_uncompat is entered. +func (s *BaseYQLListener) EnterKeyword_hint_uncompat(ctx *Keyword_hint_uncompatContext) {} + +// ExitKeyword_hint_uncompat is called when production keyword_hint_uncompat is exited. +func (s *BaseYQLListener) ExitKeyword_hint_uncompat(ctx *Keyword_hint_uncompatContext) {} + +// EnterKeyword_as_compat is called when production keyword_as_compat is entered. +func (s *BaseYQLListener) EnterKeyword_as_compat(ctx *Keyword_as_compatContext) {} + +// ExitKeyword_as_compat is called when production keyword_as_compat is exited. +func (s *BaseYQLListener) ExitKeyword_as_compat(ctx *Keyword_as_compatContext) {} + +// EnterKeyword_compat is called when production keyword_compat is entered. +func (s *BaseYQLListener) EnterKeyword_compat(ctx *Keyword_compatContext) {} + +// ExitKeyword_compat is called when production keyword_compat is exited. +func (s *BaseYQLListener) ExitKeyword_compat(ctx *Keyword_compatContext) {} + +// EnterType_id is called when production type_id is entered. +func (s *BaseYQLListener) EnterType_id(ctx *Type_idContext) {} + +// ExitType_id is called when production type_id is exited. +func (s *BaseYQLListener) ExitType_id(ctx *Type_idContext) {} + +// EnterBool_value is called when production bool_value is entered. +func (s *BaseYQLListener) EnterBool_value(ctx *Bool_valueContext) {} + +// ExitBool_value is called when production bool_value is exited. +func (s *BaseYQLListener) ExitBool_value(ctx *Bool_valueContext) {} + +// EnterReal is called when production real is entered. +func (s *BaseYQLListener) EnterReal(ctx *RealContext) {} + +// ExitReal is called when production real is exited. +func (s *BaseYQLListener) ExitReal(ctx *RealContext) {} + +// EnterInteger is called when production integer is entered. +func (s *BaseYQLListener) EnterInteger(ctx *IntegerContext) {} + +// ExitInteger is called when production integer is exited. +func (s *BaseYQLListener) ExitInteger(ctx *IntegerContext) {} diff --git a/parser/yql/yqlv1antlr4_lexer.go b/parser/yql/yql_lexer.go similarity index 91% rename from parser/yql/yqlv1antlr4_lexer.go rename to parser/yql/yql_lexer.go index ec4659c37..ba9c80fd5 100644 --- a/parser/yql/yqlv1antlr4_lexer.go +++ b/parser/yql/yql_lexer.go @@ -1,4 +1,4 @@ -// Code generated from YQLv1Antlr4.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from YQL.g4 by ANTLR 4.13.2. DO NOT EDIT. package yql import ( @@ -13,14 +13,14 @@ var _ = sync.Once{} var _ = unicode.IsLetter -type YQLv1Antlr4Lexer struct { +type YQLLexer struct { *antlr.BaseLexer channelNames []string modeNames []string // TODO: EOF string } -var YQLv1Antlr4LexerLexerStaticData struct { +var YQLLexerLexerStaticData struct { once sync.Once serializedATN []int32 ChannelNames []string @@ -33,8 +33,8 @@ var YQLv1Antlr4LexerLexerStaticData struct { decisionToDFA []*antlr.DFA } -func yqlv1antlr4lexerLexerInit() { - staticData := &YQLv1Antlr4LexerLexerStaticData +func yqllexerLexerInit() { + staticData := &YQLLexerLexerStaticData staticData.ChannelNames = []string{ "DEFAULT_TOKEN_CHANNEL", "HIDDEN", } @@ -1663,366 +1663,366 @@ func yqlv1antlr4lexerLexerInit() { } } -// YQLv1Antlr4LexerInit initializes any static state used to implement YQLv1Antlr4Lexer. By default the +// YQLLexerInit initializes any static state used to implement YQLLexer. By default the // static state used to implement the lexer is lazily initialized during the first call to -// NewYQLv1Antlr4Lexer(). You can call this function if you wish to initialize the static state ahead +// NewYQLLexer(). You can call this function if you wish to initialize the static state ahead // of time. -func YQLv1Antlr4LexerInit() { - staticData := &YQLv1Antlr4LexerLexerStaticData - staticData.once.Do(yqlv1antlr4lexerLexerInit) +func YQLLexerInit() { + staticData := &YQLLexerLexerStaticData + staticData.once.Do(yqllexerLexerInit) } -// NewYQLv1Antlr4Lexer produces a new lexer instance for the optional input antlr.CharStream. -func NewYQLv1Antlr4Lexer(input antlr.CharStream) *YQLv1Antlr4Lexer { - YQLv1Antlr4LexerInit() - l := new(YQLv1Antlr4Lexer) +// NewYQLLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewYQLLexer(input antlr.CharStream) *YQLLexer { + YQLLexerInit() + l := new(YQLLexer) l.BaseLexer = antlr.NewBaseLexer(input) - staticData := &YQLv1Antlr4LexerLexerStaticData + staticData := &YQLLexerLexerStaticData l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) l.channelNames = staticData.ChannelNames l.modeNames = staticData.ModeNames l.RuleNames = staticData.RuleNames l.LiteralNames = staticData.LiteralNames l.SymbolicNames = staticData.SymbolicNames - l.GrammarFileName = "YQLv1Antlr4.g4" + l.GrammarFileName = "YQL.g4" // TODO: l.EOF = antlr.TokenEOF return l } -// YQLv1Antlr4Lexer tokens. +// YQLLexer tokens. const ( - YQLv1Antlr4LexerEQUALS = 1 - YQLv1Antlr4LexerEQUALS2 = 2 - YQLv1Antlr4LexerNOT_EQUALS = 3 - YQLv1Antlr4LexerNOT_EQUALS2 = 4 - YQLv1Antlr4LexerLESS = 5 - YQLv1Antlr4LexerLESS_OR_EQ = 6 - YQLv1Antlr4LexerGREATER = 7 - YQLv1Antlr4LexerGREATER_OR_EQ = 8 - YQLv1Antlr4LexerSHIFT_LEFT = 9 - YQLv1Antlr4LexerROT_LEFT = 10 - YQLv1Antlr4LexerAMPERSAND = 11 - YQLv1Antlr4LexerPIPE = 12 - YQLv1Antlr4LexerDOUBLE_PIPE = 13 - YQLv1Antlr4LexerSTRUCT_OPEN = 14 - YQLv1Antlr4LexerSTRUCT_CLOSE = 15 - YQLv1Antlr4LexerPLUS = 16 - YQLv1Antlr4LexerMINUS = 17 - YQLv1Antlr4LexerTILDA = 18 - YQLv1Antlr4LexerASTERISK = 19 - YQLv1Antlr4LexerSLASH = 20 - YQLv1Antlr4LexerPERCENT = 21 - YQLv1Antlr4LexerSEMICOLON = 22 - YQLv1Antlr4LexerDOT = 23 - YQLv1Antlr4LexerCOMMA = 24 - YQLv1Antlr4LexerLPAREN = 25 - YQLv1Antlr4LexerRPAREN = 26 - YQLv1Antlr4LexerQUESTION = 27 - YQLv1Antlr4LexerCOLON = 28 - YQLv1Antlr4LexerCOMMAT = 29 - YQLv1Antlr4LexerDOLLAR = 30 - YQLv1Antlr4LexerLBRACE_CURLY = 31 - YQLv1Antlr4LexerRBRACE_CURLY = 32 - YQLv1Antlr4LexerCARET = 33 - YQLv1Antlr4LexerNAMESPACE = 34 - YQLv1Antlr4LexerARROW = 35 - YQLv1Antlr4LexerRBRACE_SQUARE = 36 - YQLv1Antlr4LexerLBRACE_SQUARE = 37 - YQLv1Antlr4LexerABORT = 38 - YQLv1Antlr4LexerACTION = 39 - YQLv1Antlr4LexerADD = 40 - YQLv1Antlr4LexerAFTER = 41 - YQLv1Antlr4LexerALL = 42 - YQLv1Antlr4LexerALTER = 43 - YQLv1Antlr4LexerANALYZE = 44 - YQLv1Antlr4LexerAND = 45 - YQLv1Antlr4LexerANSI = 46 - YQLv1Antlr4LexerANY = 47 - YQLv1Antlr4LexerARRAY = 48 - YQLv1Antlr4LexerAS = 49 - YQLv1Antlr4LexerASC = 50 - YQLv1Antlr4LexerASSUME = 51 - YQLv1Antlr4LexerASYMMETRIC = 52 - YQLv1Antlr4LexerASYNC = 53 - YQLv1Antlr4LexerAT = 54 - YQLv1Antlr4LexerATTACH = 55 - YQLv1Antlr4LexerATTRIBUTES = 56 - YQLv1Antlr4LexerAUTOINCREMENT = 57 - YQLv1Antlr4LexerAUTOMAP = 58 - YQLv1Antlr4LexerBACKUP = 59 - YQLv1Antlr4LexerCOLLECTION = 60 - YQLv1Antlr4LexerBEFORE = 61 - YQLv1Antlr4LexerBEGIN = 62 - YQLv1Antlr4LexerBERNOULLI = 63 - YQLv1Antlr4LexerBETWEEN = 64 - YQLv1Antlr4LexerBITCAST = 65 - YQLv1Antlr4LexerBY = 66 - YQLv1Antlr4LexerCALLABLE = 67 - YQLv1Antlr4LexerCASCADE = 68 - YQLv1Antlr4LexerCASE = 69 - YQLv1Antlr4LexerCAST = 70 - YQLv1Antlr4LexerCHANGEFEED = 71 - YQLv1Antlr4LexerCHECK = 72 - YQLv1Antlr4LexerCLASSIFIER = 73 - YQLv1Antlr4LexerCOLLATE = 74 - YQLv1Antlr4LexerCOLUMN = 75 - YQLv1Antlr4LexerCOLUMNS = 76 - YQLv1Antlr4LexerCOMMIT = 77 - YQLv1Antlr4LexerCOMPACT = 78 - YQLv1Antlr4LexerCONDITIONAL = 79 - YQLv1Antlr4LexerCONFLICT = 80 - YQLv1Antlr4LexerCONNECT = 81 - YQLv1Antlr4LexerCONSTRAINT = 82 - YQLv1Antlr4LexerCONSUMER = 83 - YQLv1Antlr4LexerCOVER = 84 - YQLv1Antlr4LexerCREATE = 85 - YQLv1Antlr4LexerCROSS = 86 - YQLv1Antlr4LexerCUBE = 87 - YQLv1Antlr4LexerCURRENT = 88 - YQLv1Antlr4LexerCURRENT_DATE = 89 - YQLv1Antlr4LexerCURRENT_TIME = 90 - YQLv1Antlr4LexerCURRENT_TIMESTAMP = 91 - YQLv1Antlr4LexerDATA = 92 - YQLv1Antlr4LexerDATABASE = 93 - YQLv1Antlr4LexerDECIMAL = 94 - YQLv1Antlr4LexerDECLARE = 95 - YQLv1Antlr4LexerDEFAULT = 96 - YQLv1Antlr4LexerDEFERRABLE = 97 - YQLv1Antlr4LexerDEFERRED = 98 - YQLv1Antlr4LexerDEFINE = 99 - YQLv1Antlr4LexerDELETE = 100 - YQLv1Antlr4LexerDESC = 101 - YQLv1Antlr4LexerDESCRIBE = 102 - YQLv1Antlr4LexerDETACH = 103 - YQLv1Antlr4LexerDICT = 104 - YQLv1Antlr4LexerDIRECTORY = 105 - YQLv1Antlr4LexerDISABLE = 106 - YQLv1Antlr4LexerDISCARD = 107 - YQLv1Antlr4LexerDISTINCT = 108 - YQLv1Antlr4LexerDO = 109 - YQLv1Antlr4LexerDROP = 110 - YQLv1Antlr4LexerEACH = 111 - YQLv1Antlr4LexerELSE = 112 - YQLv1Antlr4LexerEMPTY = 113 - YQLv1Antlr4LexerEMPTY_ACTION = 114 - YQLv1Antlr4LexerENCRYPTED = 115 - YQLv1Antlr4LexerEND = 116 - YQLv1Antlr4LexerENUM = 117 - YQLv1Antlr4LexerERASE = 118 - YQLv1Antlr4LexerERROR = 119 - YQLv1Antlr4LexerESCAPE = 120 - YQLv1Antlr4LexerEVALUATE = 121 - YQLv1Antlr4LexerEXCEPT = 122 - YQLv1Antlr4LexerEXCLUDE = 123 - YQLv1Antlr4LexerEXCLUSION = 124 - YQLv1Antlr4LexerEXCLUSIVE = 125 - YQLv1Antlr4LexerEXISTS = 126 - YQLv1Antlr4LexerEXPLAIN = 127 - YQLv1Antlr4LexerEXPORT = 128 - YQLv1Antlr4LexerEXTERNAL = 129 - YQLv1Antlr4LexerFAIL = 130 - YQLv1Antlr4LexerFALSE = 131 - YQLv1Antlr4LexerFAMILY = 132 - YQLv1Antlr4LexerFILTER = 133 - YQLv1Antlr4LexerFIRST = 134 - YQLv1Antlr4LexerFLATTEN = 135 - YQLv1Antlr4LexerFLOW = 136 - YQLv1Antlr4LexerFOLLOWING = 137 - YQLv1Antlr4LexerFOR = 138 - YQLv1Antlr4LexerFOREIGN = 139 - YQLv1Antlr4LexerFROM = 140 - YQLv1Antlr4LexerFULL = 141 - YQLv1Antlr4LexerFUNCTION = 142 - YQLv1Antlr4LexerGLOB = 143 - YQLv1Antlr4LexerGLOBAL = 144 - YQLv1Antlr4LexerGRANT = 145 - YQLv1Antlr4LexerGROUP = 146 - YQLv1Antlr4LexerGROUPING = 147 - YQLv1Antlr4LexerGROUPS = 148 - YQLv1Antlr4LexerHASH = 149 - YQLv1Antlr4LexerHAVING = 150 - YQLv1Antlr4LexerHOP = 151 - YQLv1Antlr4LexerIF = 152 - YQLv1Antlr4LexerIGNORE = 153 - YQLv1Antlr4LexerILIKE = 154 - YQLv1Antlr4LexerIMMEDIATE = 155 - YQLv1Antlr4LexerIMPORT = 156 - YQLv1Antlr4LexerIN = 157 - YQLv1Antlr4LexerINCREMENT = 158 - YQLv1Antlr4LexerINCREMENTAL = 159 - YQLv1Antlr4LexerINDEX = 160 - YQLv1Antlr4LexerINDEXED = 161 - YQLv1Antlr4LexerINHERITS = 162 - YQLv1Antlr4LexerINITIAL = 163 - YQLv1Antlr4LexerINITIALLY = 164 - YQLv1Antlr4LexerINNER = 165 - YQLv1Antlr4LexerINSERT = 166 - YQLv1Antlr4LexerINSTEAD = 167 - YQLv1Antlr4LexerINTERSECT = 168 - YQLv1Antlr4LexerINTO = 169 - YQLv1Antlr4LexerIS = 170 - YQLv1Antlr4LexerISNULL = 171 - YQLv1Antlr4LexerJOIN = 172 - YQLv1Antlr4LexerJSON_EXISTS = 173 - YQLv1Antlr4LexerJSON_QUERY = 174 - YQLv1Antlr4LexerJSON_VALUE = 175 - YQLv1Antlr4LexerKEY = 176 - YQLv1Antlr4LexerLAST = 177 - YQLv1Antlr4LexerLEFT = 178 - YQLv1Antlr4LexerLEGACY = 179 - YQLv1Antlr4LexerLIKE = 180 - YQLv1Antlr4LexerLIMIT = 181 - YQLv1Antlr4LexerLIST = 182 - YQLv1Antlr4LexerLOCAL = 183 - YQLv1Antlr4LexerLOGIN = 184 - YQLv1Antlr4LexerMANAGE = 185 - YQLv1Antlr4LexerMATCH = 186 - YQLv1Antlr4LexerMATCHES = 187 - YQLv1Antlr4LexerMATCH_RECOGNIZE = 188 - YQLv1Antlr4LexerMEASURES = 189 - YQLv1Antlr4LexerMICROSECONDS = 190 - YQLv1Antlr4LexerMILLISECONDS = 191 - YQLv1Antlr4LexerMODIFY = 192 - YQLv1Antlr4LexerNANOSECONDS = 193 - YQLv1Antlr4LexerNATURAL = 194 - YQLv1Antlr4LexerNEXT = 195 - YQLv1Antlr4LexerNO = 196 - YQLv1Antlr4LexerNOLOGIN = 197 - YQLv1Antlr4LexerNOT = 198 - YQLv1Antlr4LexerNOTNULL = 199 - YQLv1Antlr4LexerNULL = 200 - YQLv1Antlr4LexerNULLS = 201 - YQLv1Antlr4LexerOBJECT = 202 - YQLv1Antlr4LexerOF = 203 - YQLv1Antlr4LexerOFFSET = 204 - YQLv1Antlr4LexerOMIT = 205 - YQLv1Antlr4LexerON = 206 - YQLv1Antlr4LexerONE = 207 - YQLv1Antlr4LexerONLY = 208 - YQLv1Antlr4LexerOPTION = 209 - YQLv1Antlr4LexerOPTIONAL = 210 - YQLv1Antlr4LexerOR = 211 - YQLv1Antlr4LexerORDER = 212 - YQLv1Antlr4LexerOTHERS = 213 - YQLv1Antlr4LexerOUTER = 214 - YQLv1Antlr4LexerOVER = 215 - YQLv1Antlr4LexerPARALLEL = 216 - YQLv1Antlr4LexerPARTITION = 217 - YQLv1Antlr4LexerPASSING = 218 - YQLv1Antlr4LexerPASSWORD = 219 - YQLv1Antlr4LexerPAST = 220 - YQLv1Antlr4LexerPATTERN = 221 - YQLv1Antlr4LexerPER = 222 - YQLv1Antlr4LexerPERMUTE = 223 - YQLv1Antlr4LexerPLAN = 224 - YQLv1Antlr4LexerPOOL = 225 - YQLv1Antlr4LexerPRAGMA = 226 - YQLv1Antlr4LexerPRECEDING = 227 - YQLv1Antlr4LexerPRESORT = 228 - YQLv1Antlr4LexerPRIMARY = 229 - YQLv1Antlr4LexerPRIVILEGES = 230 - YQLv1Antlr4LexerPROCESS = 231 - YQLv1Antlr4LexerQUERY = 232 - YQLv1Antlr4LexerQUEUE = 233 - YQLv1Antlr4LexerRAISE = 234 - YQLv1Antlr4LexerRANGE = 235 - YQLv1Antlr4LexerREDUCE = 236 - YQLv1Antlr4LexerREFERENCES = 237 - YQLv1Antlr4LexerREGEXP = 238 - YQLv1Antlr4LexerREINDEX = 239 - YQLv1Antlr4LexerRELEASE = 240 - YQLv1Antlr4LexerREMOVE = 241 - YQLv1Antlr4LexerRENAME = 242 - YQLv1Antlr4LexerREPEATABLE = 243 - YQLv1Antlr4LexerREPLACE = 244 - YQLv1Antlr4LexerREPLICATION = 245 - YQLv1Antlr4LexerRESET = 246 - YQLv1Antlr4LexerRESOURCE = 247 - YQLv1Antlr4LexerRESPECT = 248 - YQLv1Antlr4LexerRESTART = 249 - YQLv1Antlr4LexerRESTORE = 250 - YQLv1Antlr4LexerRESTRICT = 251 - YQLv1Antlr4LexerRESULT = 252 - YQLv1Antlr4LexerRETURN = 253 - YQLv1Antlr4LexerRETURNING = 254 - YQLv1Antlr4LexerREVERT = 255 - YQLv1Antlr4LexerREVOKE = 256 - YQLv1Antlr4LexerRIGHT = 257 - YQLv1Antlr4LexerRLIKE = 258 - YQLv1Antlr4LexerROLLBACK = 259 - YQLv1Antlr4LexerROLLUP = 260 - YQLv1Antlr4LexerROW = 261 - YQLv1Antlr4LexerROWS = 262 - YQLv1Antlr4LexerSAMPLE = 263 - YQLv1Antlr4LexerSAVEPOINT = 264 - YQLv1Antlr4LexerSCHEMA = 265 - YQLv1Antlr4LexerSECONDS = 266 - YQLv1Antlr4LexerSEEK = 267 - YQLv1Antlr4LexerSELECT = 268 - YQLv1Antlr4LexerSEMI = 269 - YQLv1Antlr4LexerSET = 270 - YQLv1Antlr4LexerSETS = 271 - YQLv1Antlr4LexerSHOW = 272 - YQLv1Antlr4LexerTSKIP = 273 - YQLv1Antlr4LexerSEQUENCE = 274 - YQLv1Antlr4LexerSOURCE = 275 - YQLv1Antlr4LexerSTART = 276 - YQLv1Antlr4LexerSTREAM = 277 - YQLv1Antlr4LexerSTRUCT = 278 - YQLv1Antlr4LexerSUBQUERY = 279 - YQLv1Antlr4LexerSUBSET = 280 - YQLv1Antlr4LexerSYMBOLS = 281 - YQLv1Antlr4LexerSYMMETRIC = 282 - YQLv1Antlr4LexerSYNC = 283 - YQLv1Antlr4LexerSYSTEM = 284 - YQLv1Antlr4LexerTABLE = 285 - YQLv1Antlr4LexerTABLES = 286 - YQLv1Antlr4LexerTABLESAMPLE = 287 - YQLv1Antlr4LexerTABLESTORE = 288 - YQLv1Antlr4LexerTAGGED = 289 - YQLv1Antlr4LexerTEMP = 290 - YQLv1Antlr4LexerTEMPORARY = 291 - YQLv1Antlr4LexerTHEN = 292 - YQLv1Antlr4LexerTIES = 293 - YQLv1Antlr4LexerTO = 294 - YQLv1Antlr4LexerTOPIC = 295 - YQLv1Antlr4LexerTRANSACTION = 296 - YQLv1Antlr4LexerTRIGGER = 297 - YQLv1Antlr4LexerTRUE = 298 - YQLv1Antlr4LexerTUPLE = 299 - YQLv1Antlr4LexerTYPE = 300 - YQLv1Antlr4LexerUNBOUNDED = 301 - YQLv1Antlr4LexerUNCONDITIONAL = 302 - YQLv1Antlr4LexerUNION = 303 - YQLv1Antlr4LexerUNIQUE = 304 - YQLv1Antlr4LexerUNKNOWN = 305 - YQLv1Antlr4LexerUNMATCHED = 306 - YQLv1Antlr4LexerUPDATE = 307 - YQLv1Antlr4LexerUPSERT = 308 - YQLv1Antlr4LexerUSE = 309 - YQLv1Antlr4LexerUSER = 310 - YQLv1Antlr4LexerUSING = 311 - YQLv1Antlr4LexerVACUUM = 312 - YQLv1Antlr4LexerVALUES = 313 - YQLv1Antlr4LexerVARIANT = 314 - YQLv1Antlr4LexerVIEW = 315 - YQLv1Antlr4LexerVIRTUAL = 316 - YQLv1Antlr4LexerWHEN = 317 - YQLv1Antlr4LexerWHERE = 318 - YQLv1Antlr4LexerWINDOW = 319 - YQLv1Antlr4LexerWITH = 320 - YQLv1Antlr4LexerWITHOUT = 321 - YQLv1Antlr4LexerWRAPPER = 322 - YQLv1Antlr4LexerXOR = 323 - YQLv1Antlr4LexerSTRING_VALUE = 324 - YQLv1Antlr4LexerID_PLAIN = 325 - YQLv1Antlr4LexerID_QUOTED = 326 - YQLv1Antlr4LexerDIGITS = 327 - YQLv1Antlr4LexerINTEGER_VALUE = 328 - YQLv1Antlr4LexerREAL = 329 - YQLv1Antlr4LexerBLOB = 330 - YQLv1Antlr4LexerWS = 331 - YQLv1Antlr4LexerCOMMENT = 332 + YQLLexerEQUALS = 1 + YQLLexerEQUALS2 = 2 + YQLLexerNOT_EQUALS = 3 + YQLLexerNOT_EQUALS2 = 4 + YQLLexerLESS = 5 + YQLLexerLESS_OR_EQ = 6 + YQLLexerGREATER = 7 + YQLLexerGREATER_OR_EQ = 8 + YQLLexerSHIFT_LEFT = 9 + YQLLexerROT_LEFT = 10 + YQLLexerAMPERSAND = 11 + YQLLexerPIPE = 12 + YQLLexerDOUBLE_PIPE = 13 + YQLLexerSTRUCT_OPEN = 14 + YQLLexerSTRUCT_CLOSE = 15 + YQLLexerPLUS = 16 + YQLLexerMINUS = 17 + YQLLexerTILDA = 18 + YQLLexerASTERISK = 19 + YQLLexerSLASH = 20 + YQLLexerPERCENT = 21 + YQLLexerSEMICOLON = 22 + YQLLexerDOT = 23 + YQLLexerCOMMA = 24 + YQLLexerLPAREN = 25 + YQLLexerRPAREN = 26 + YQLLexerQUESTION = 27 + YQLLexerCOLON = 28 + YQLLexerCOMMAT = 29 + YQLLexerDOLLAR = 30 + YQLLexerLBRACE_CURLY = 31 + YQLLexerRBRACE_CURLY = 32 + YQLLexerCARET = 33 + YQLLexerNAMESPACE = 34 + YQLLexerARROW = 35 + YQLLexerRBRACE_SQUARE = 36 + YQLLexerLBRACE_SQUARE = 37 + YQLLexerABORT = 38 + YQLLexerACTION = 39 + YQLLexerADD = 40 + YQLLexerAFTER = 41 + YQLLexerALL = 42 + YQLLexerALTER = 43 + YQLLexerANALYZE = 44 + YQLLexerAND = 45 + YQLLexerANSI = 46 + YQLLexerANY = 47 + YQLLexerARRAY = 48 + YQLLexerAS = 49 + YQLLexerASC = 50 + YQLLexerASSUME = 51 + YQLLexerASYMMETRIC = 52 + YQLLexerASYNC = 53 + YQLLexerAT = 54 + YQLLexerATTACH = 55 + YQLLexerATTRIBUTES = 56 + YQLLexerAUTOINCREMENT = 57 + YQLLexerAUTOMAP = 58 + YQLLexerBACKUP = 59 + YQLLexerCOLLECTION = 60 + YQLLexerBEFORE = 61 + YQLLexerBEGIN = 62 + YQLLexerBERNOULLI = 63 + YQLLexerBETWEEN = 64 + YQLLexerBITCAST = 65 + YQLLexerBY = 66 + YQLLexerCALLABLE = 67 + YQLLexerCASCADE = 68 + YQLLexerCASE = 69 + YQLLexerCAST = 70 + YQLLexerCHANGEFEED = 71 + YQLLexerCHECK = 72 + YQLLexerCLASSIFIER = 73 + YQLLexerCOLLATE = 74 + YQLLexerCOLUMN = 75 + YQLLexerCOLUMNS = 76 + YQLLexerCOMMIT = 77 + YQLLexerCOMPACT = 78 + YQLLexerCONDITIONAL = 79 + YQLLexerCONFLICT = 80 + YQLLexerCONNECT = 81 + YQLLexerCONSTRAINT = 82 + YQLLexerCONSUMER = 83 + YQLLexerCOVER = 84 + YQLLexerCREATE = 85 + YQLLexerCROSS = 86 + YQLLexerCUBE = 87 + YQLLexerCURRENT = 88 + YQLLexerCURRENT_DATE = 89 + YQLLexerCURRENT_TIME = 90 + YQLLexerCURRENT_TIMESTAMP = 91 + YQLLexerDATA = 92 + YQLLexerDATABASE = 93 + YQLLexerDECIMAL = 94 + YQLLexerDECLARE = 95 + YQLLexerDEFAULT = 96 + YQLLexerDEFERRABLE = 97 + YQLLexerDEFERRED = 98 + YQLLexerDEFINE = 99 + YQLLexerDELETE = 100 + YQLLexerDESC = 101 + YQLLexerDESCRIBE = 102 + YQLLexerDETACH = 103 + YQLLexerDICT = 104 + YQLLexerDIRECTORY = 105 + YQLLexerDISABLE = 106 + YQLLexerDISCARD = 107 + YQLLexerDISTINCT = 108 + YQLLexerDO = 109 + YQLLexerDROP = 110 + YQLLexerEACH = 111 + YQLLexerELSE = 112 + YQLLexerEMPTY = 113 + YQLLexerEMPTY_ACTION = 114 + YQLLexerENCRYPTED = 115 + YQLLexerEND = 116 + YQLLexerENUM = 117 + YQLLexerERASE = 118 + YQLLexerERROR = 119 + YQLLexerESCAPE = 120 + YQLLexerEVALUATE = 121 + YQLLexerEXCEPT = 122 + YQLLexerEXCLUDE = 123 + YQLLexerEXCLUSION = 124 + YQLLexerEXCLUSIVE = 125 + YQLLexerEXISTS = 126 + YQLLexerEXPLAIN = 127 + YQLLexerEXPORT = 128 + YQLLexerEXTERNAL = 129 + YQLLexerFAIL = 130 + YQLLexerFALSE = 131 + YQLLexerFAMILY = 132 + YQLLexerFILTER = 133 + YQLLexerFIRST = 134 + YQLLexerFLATTEN = 135 + YQLLexerFLOW = 136 + YQLLexerFOLLOWING = 137 + YQLLexerFOR = 138 + YQLLexerFOREIGN = 139 + YQLLexerFROM = 140 + YQLLexerFULL = 141 + YQLLexerFUNCTION = 142 + YQLLexerGLOB = 143 + YQLLexerGLOBAL = 144 + YQLLexerGRANT = 145 + YQLLexerGROUP = 146 + YQLLexerGROUPING = 147 + YQLLexerGROUPS = 148 + YQLLexerHASH = 149 + YQLLexerHAVING = 150 + YQLLexerHOP = 151 + YQLLexerIF = 152 + YQLLexerIGNORE = 153 + YQLLexerILIKE = 154 + YQLLexerIMMEDIATE = 155 + YQLLexerIMPORT = 156 + YQLLexerIN = 157 + YQLLexerINCREMENT = 158 + YQLLexerINCREMENTAL = 159 + YQLLexerINDEX = 160 + YQLLexerINDEXED = 161 + YQLLexerINHERITS = 162 + YQLLexerINITIAL = 163 + YQLLexerINITIALLY = 164 + YQLLexerINNER = 165 + YQLLexerINSERT = 166 + YQLLexerINSTEAD = 167 + YQLLexerINTERSECT = 168 + YQLLexerINTO = 169 + YQLLexerIS = 170 + YQLLexerISNULL = 171 + YQLLexerJOIN = 172 + YQLLexerJSON_EXISTS = 173 + YQLLexerJSON_QUERY = 174 + YQLLexerJSON_VALUE = 175 + YQLLexerKEY = 176 + YQLLexerLAST = 177 + YQLLexerLEFT = 178 + YQLLexerLEGACY = 179 + YQLLexerLIKE = 180 + YQLLexerLIMIT = 181 + YQLLexerLIST = 182 + YQLLexerLOCAL = 183 + YQLLexerLOGIN = 184 + YQLLexerMANAGE = 185 + YQLLexerMATCH = 186 + YQLLexerMATCHES = 187 + YQLLexerMATCH_RECOGNIZE = 188 + YQLLexerMEASURES = 189 + YQLLexerMICROSECONDS = 190 + YQLLexerMILLISECONDS = 191 + YQLLexerMODIFY = 192 + YQLLexerNANOSECONDS = 193 + YQLLexerNATURAL = 194 + YQLLexerNEXT = 195 + YQLLexerNO = 196 + YQLLexerNOLOGIN = 197 + YQLLexerNOT = 198 + YQLLexerNOTNULL = 199 + YQLLexerNULL = 200 + YQLLexerNULLS = 201 + YQLLexerOBJECT = 202 + YQLLexerOF = 203 + YQLLexerOFFSET = 204 + YQLLexerOMIT = 205 + YQLLexerON = 206 + YQLLexerONE = 207 + YQLLexerONLY = 208 + YQLLexerOPTION = 209 + YQLLexerOPTIONAL = 210 + YQLLexerOR = 211 + YQLLexerORDER = 212 + YQLLexerOTHERS = 213 + YQLLexerOUTER = 214 + YQLLexerOVER = 215 + YQLLexerPARALLEL = 216 + YQLLexerPARTITION = 217 + YQLLexerPASSING = 218 + YQLLexerPASSWORD = 219 + YQLLexerPAST = 220 + YQLLexerPATTERN = 221 + YQLLexerPER = 222 + YQLLexerPERMUTE = 223 + YQLLexerPLAN = 224 + YQLLexerPOOL = 225 + YQLLexerPRAGMA = 226 + YQLLexerPRECEDING = 227 + YQLLexerPRESORT = 228 + YQLLexerPRIMARY = 229 + YQLLexerPRIVILEGES = 230 + YQLLexerPROCESS = 231 + YQLLexerQUERY = 232 + YQLLexerQUEUE = 233 + YQLLexerRAISE = 234 + YQLLexerRANGE = 235 + YQLLexerREDUCE = 236 + YQLLexerREFERENCES = 237 + YQLLexerREGEXP = 238 + YQLLexerREINDEX = 239 + YQLLexerRELEASE = 240 + YQLLexerREMOVE = 241 + YQLLexerRENAME = 242 + YQLLexerREPEATABLE = 243 + YQLLexerREPLACE = 244 + YQLLexerREPLICATION = 245 + YQLLexerRESET = 246 + YQLLexerRESOURCE = 247 + YQLLexerRESPECT = 248 + YQLLexerRESTART = 249 + YQLLexerRESTORE = 250 + YQLLexerRESTRICT = 251 + YQLLexerRESULT = 252 + YQLLexerRETURN = 253 + YQLLexerRETURNING = 254 + YQLLexerREVERT = 255 + YQLLexerREVOKE = 256 + YQLLexerRIGHT = 257 + YQLLexerRLIKE = 258 + YQLLexerROLLBACK = 259 + YQLLexerROLLUP = 260 + YQLLexerROW = 261 + YQLLexerROWS = 262 + YQLLexerSAMPLE = 263 + YQLLexerSAVEPOINT = 264 + YQLLexerSCHEMA = 265 + YQLLexerSECONDS = 266 + YQLLexerSEEK = 267 + YQLLexerSELECT = 268 + YQLLexerSEMI = 269 + YQLLexerSET = 270 + YQLLexerSETS = 271 + YQLLexerSHOW = 272 + YQLLexerTSKIP = 273 + YQLLexerSEQUENCE = 274 + YQLLexerSOURCE = 275 + YQLLexerSTART = 276 + YQLLexerSTREAM = 277 + YQLLexerSTRUCT = 278 + YQLLexerSUBQUERY = 279 + YQLLexerSUBSET = 280 + YQLLexerSYMBOLS = 281 + YQLLexerSYMMETRIC = 282 + YQLLexerSYNC = 283 + YQLLexerSYSTEM = 284 + YQLLexerTABLE = 285 + YQLLexerTABLES = 286 + YQLLexerTABLESAMPLE = 287 + YQLLexerTABLESTORE = 288 + YQLLexerTAGGED = 289 + YQLLexerTEMP = 290 + YQLLexerTEMPORARY = 291 + YQLLexerTHEN = 292 + YQLLexerTIES = 293 + YQLLexerTO = 294 + YQLLexerTOPIC = 295 + YQLLexerTRANSACTION = 296 + YQLLexerTRIGGER = 297 + YQLLexerTRUE = 298 + YQLLexerTUPLE = 299 + YQLLexerTYPE = 300 + YQLLexerUNBOUNDED = 301 + YQLLexerUNCONDITIONAL = 302 + YQLLexerUNION = 303 + YQLLexerUNIQUE = 304 + YQLLexerUNKNOWN = 305 + YQLLexerUNMATCHED = 306 + YQLLexerUPDATE = 307 + YQLLexerUPSERT = 308 + YQLLexerUSE = 309 + YQLLexerUSER = 310 + YQLLexerUSING = 311 + YQLLexerVACUUM = 312 + YQLLexerVALUES = 313 + YQLLexerVARIANT = 314 + YQLLexerVIEW = 315 + YQLLexerVIRTUAL = 316 + YQLLexerWHEN = 317 + YQLLexerWHERE = 318 + YQLLexerWINDOW = 319 + YQLLexerWITH = 320 + YQLLexerWITHOUT = 321 + YQLLexerWRAPPER = 322 + YQLLexerXOR = 323 + YQLLexerSTRING_VALUE = 324 + YQLLexerID_PLAIN = 325 + YQLLexerID_QUOTED = 326 + YQLLexerDIGITS = 327 + YQLLexerINTEGER_VALUE = 328 + YQLLexerREAL = 329 + YQLLexerBLOB = 330 + YQLLexerWS = 331 + YQLLexerCOMMENT = 332 ) diff --git a/parser/yql/yqlv1antlr4_listener.go b/parser/yql/yql_listener.go similarity index 99% rename from parser/yql/yqlv1antlr4_listener.go rename to parser/yql/yql_listener.go index 6cc65e435..8f27e5e70 100644 --- a/parser/yql/yqlv1antlr4_listener.go +++ b/parser/yql/yql_listener.go @@ -1,11 +1,11 @@ -// Code generated from YQLv1Antlr4.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from YQL.g4 by ANTLR 4.13.2. DO NOT EDIT. -package yql // YQLv1Antlr4 +package yql // YQL import "github.com/antlr4-go/antlr/v4" -// YQLv1Antlr4Listener is a complete listener for a parse tree produced by YQLv1Antlr4Parser. -type YQLv1Antlr4Listener interface { +// YQLListener is a complete listener for a parse tree produced by YQLParser. +type YQLListener interface { antlr.ParseTreeListener // EnterSql_query is called when entering the sql_query production. diff --git a/parser/yql/yqlv1antlr4_parser.go b/parser/yql/yql_parser.go similarity index 75% rename from parser/yql/yqlv1antlr4_parser.go rename to parser/yql/yql_parser.go index 63eb107a3..0b02ead74 100644 --- a/parser/yql/yqlv1antlr4_parser.go +++ b/parser/yql/yql_parser.go @@ -1,6 +1,6 @@ -// Code generated from YQLv1Antlr4.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from YQL.g4 by ANTLR 4.13.2. DO NOT EDIT. -package yql // YQLv1Antlr4 +package yql // YQL import ( "fmt" "strconv" @@ -15,11 +15,11 @@ var _ = strconv.Itoa var _ = sync.Once{} -type YQLv1Antlr4Parser struct { +type YQLParser struct { *antlr.BaseParser } -var YQLv1Antlr4ParserStaticData struct { +var YQLParserStaticData struct { once sync.Once serializedATN []int32 LiteralNames []string @@ -30,8 +30,8 @@ var YQLv1Antlr4ParserStaticData struct { decisionToDFA []*antlr.DFA } -func yqlv1antlr4ParserInit() { - staticData := &YQLv1Antlr4ParserStaticData +func yqlParserInit() { + staticData := &YQLParserStaticData staticData.LiteralNames = []string{ "", "'='", "'=='", "'!='", "'<>'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'|<<'", "'&'", "'|'", "'||'", "'<|'", "'|>'", "'+'", "'-'", "'~'", @@ -2528,803 +2528,803 @@ func yqlv1antlr4ParserInit() { } } -// YQLv1Antlr4ParserInit initializes any static state used to implement YQLv1Antlr4Parser. By default the +// YQLParserInit initializes any static state used to implement YQLParser. By default the // static state used to implement the parser is lazily initialized during the first call to -// NewYQLv1Antlr4Parser(). You can call this function if you wish to initialize the static state ahead +// NewYQLParser(). You can call this function if you wish to initialize the static state ahead // of time. -func YQLv1Antlr4ParserInit() { - staticData := &YQLv1Antlr4ParserStaticData - staticData.once.Do(yqlv1antlr4ParserInit) +func YQLParserInit() { + staticData := &YQLParserStaticData + staticData.once.Do(yqlParserInit) } -// NewYQLv1Antlr4Parser produces a new parser instance for the optional input antlr.TokenStream. -func NewYQLv1Antlr4Parser(input antlr.TokenStream) *YQLv1Antlr4Parser { - YQLv1Antlr4ParserInit() - this := new(YQLv1Antlr4Parser) +// NewYQLParser produces a new parser instance for the optional input antlr.TokenStream. +func NewYQLParser(input antlr.TokenStream) *YQLParser { + YQLParserInit() + this := new(YQLParser) this.BaseParser = antlr.NewBaseParser(input) - staticData := &YQLv1Antlr4ParserStaticData + staticData := &YQLParserStaticData this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) this.RuleNames = staticData.RuleNames this.LiteralNames = staticData.LiteralNames this.SymbolicNames = staticData.SymbolicNames - this.GrammarFileName = "YQLv1Antlr4.g4" + this.GrammarFileName = "YQL.g4" return this } -// YQLv1Antlr4Parser tokens. +// YQLParser tokens. const ( - YQLv1Antlr4ParserEOF = antlr.TokenEOF - YQLv1Antlr4ParserEQUALS = 1 - YQLv1Antlr4ParserEQUALS2 = 2 - YQLv1Antlr4ParserNOT_EQUALS = 3 - YQLv1Antlr4ParserNOT_EQUALS2 = 4 - YQLv1Antlr4ParserLESS = 5 - YQLv1Antlr4ParserLESS_OR_EQ = 6 - YQLv1Antlr4ParserGREATER = 7 - YQLv1Antlr4ParserGREATER_OR_EQ = 8 - YQLv1Antlr4ParserSHIFT_LEFT = 9 - YQLv1Antlr4ParserROT_LEFT = 10 - YQLv1Antlr4ParserAMPERSAND = 11 - YQLv1Antlr4ParserPIPE = 12 - YQLv1Antlr4ParserDOUBLE_PIPE = 13 - YQLv1Antlr4ParserSTRUCT_OPEN = 14 - YQLv1Antlr4ParserSTRUCT_CLOSE = 15 - YQLv1Antlr4ParserPLUS = 16 - YQLv1Antlr4ParserMINUS = 17 - YQLv1Antlr4ParserTILDA = 18 - YQLv1Antlr4ParserASTERISK = 19 - YQLv1Antlr4ParserSLASH = 20 - YQLv1Antlr4ParserPERCENT = 21 - YQLv1Antlr4ParserSEMICOLON = 22 - YQLv1Antlr4ParserDOT = 23 - YQLv1Antlr4ParserCOMMA = 24 - YQLv1Antlr4ParserLPAREN = 25 - YQLv1Antlr4ParserRPAREN = 26 - YQLv1Antlr4ParserQUESTION = 27 - YQLv1Antlr4ParserCOLON = 28 - YQLv1Antlr4ParserCOMMAT = 29 - YQLv1Antlr4ParserDOLLAR = 30 - YQLv1Antlr4ParserLBRACE_CURLY = 31 - YQLv1Antlr4ParserRBRACE_CURLY = 32 - YQLv1Antlr4ParserCARET = 33 - YQLv1Antlr4ParserNAMESPACE = 34 - YQLv1Antlr4ParserARROW = 35 - YQLv1Antlr4ParserRBRACE_SQUARE = 36 - YQLv1Antlr4ParserLBRACE_SQUARE = 37 - YQLv1Antlr4ParserABORT = 38 - YQLv1Antlr4ParserACTION = 39 - YQLv1Antlr4ParserADD = 40 - YQLv1Antlr4ParserAFTER = 41 - YQLv1Antlr4ParserALL = 42 - YQLv1Antlr4ParserALTER = 43 - YQLv1Antlr4ParserANALYZE = 44 - YQLv1Antlr4ParserAND = 45 - YQLv1Antlr4ParserANSI = 46 - YQLv1Antlr4ParserANY = 47 - YQLv1Antlr4ParserARRAY = 48 - YQLv1Antlr4ParserAS = 49 - YQLv1Antlr4ParserASC = 50 - YQLv1Antlr4ParserASSUME = 51 - YQLv1Antlr4ParserASYMMETRIC = 52 - YQLv1Antlr4ParserASYNC = 53 - YQLv1Antlr4ParserAT = 54 - YQLv1Antlr4ParserATTACH = 55 - YQLv1Antlr4ParserATTRIBUTES = 56 - YQLv1Antlr4ParserAUTOINCREMENT = 57 - YQLv1Antlr4ParserAUTOMAP = 58 - YQLv1Antlr4ParserBACKUP = 59 - YQLv1Antlr4ParserCOLLECTION = 60 - YQLv1Antlr4ParserBEFORE = 61 - YQLv1Antlr4ParserBEGIN = 62 - YQLv1Antlr4ParserBERNOULLI = 63 - YQLv1Antlr4ParserBETWEEN = 64 - YQLv1Antlr4ParserBITCAST = 65 - YQLv1Antlr4ParserBY = 66 - YQLv1Antlr4ParserCALLABLE = 67 - YQLv1Antlr4ParserCASCADE = 68 - YQLv1Antlr4ParserCASE = 69 - YQLv1Antlr4ParserCAST = 70 - YQLv1Antlr4ParserCHANGEFEED = 71 - YQLv1Antlr4ParserCHECK = 72 - YQLv1Antlr4ParserCLASSIFIER = 73 - YQLv1Antlr4ParserCOLLATE = 74 - YQLv1Antlr4ParserCOLUMN = 75 - YQLv1Antlr4ParserCOLUMNS = 76 - YQLv1Antlr4ParserCOMMIT = 77 - YQLv1Antlr4ParserCOMPACT = 78 - YQLv1Antlr4ParserCONDITIONAL = 79 - YQLv1Antlr4ParserCONFLICT = 80 - YQLv1Antlr4ParserCONNECT = 81 - YQLv1Antlr4ParserCONSTRAINT = 82 - YQLv1Antlr4ParserCONSUMER = 83 - YQLv1Antlr4ParserCOVER = 84 - YQLv1Antlr4ParserCREATE = 85 - YQLv1Antlr4ParserCROSS = 86 - YQLv1Antlr4ParserCUBE = 87 - YQLv1Antlr4ParserCURRENT = 88 - YQLv1Antlr4ParserCURRENT_DATE = 89 - YQLv1Antlr4ParserCURRENT_TIME = 90 - YQLv1Antlr4ParserCURRENT_TIMESTAMP = 91 - YQLv1Antlr4ParserDATA = 92 - YQLv1Antlr4ParserDATABASE = 93 - YQLv1Antlr4ParserDECIMAL = 94 - YQLv1Antlr4ParserDECLARE = 95 - YQLv1Antlr4ParserDEFAULT = 96 - YQLv1Antlr4ParserDEFERRABLE = 97 - YQLv1Antlr4ParserDEFERRED = 98 - YQLv1Antlr4ParserDEFINE = 99 - YQLv1Antlr4ParserDELETE = 100 - YQLv1Antlr4ParserDESC = 101 - YQLv1Antlr4ParserDESCRIBE = 102 - YQLv1Antlr4ParserDETACH = 103 - YQLv1Antlr4ParserDICT = 104 - YQLv1Antlr4ParserDIRECTORY = 105 - YQLv1Antlr4ParserDISABLE = 106 - YQLv1Antlr4ParserDISCARD = 107 - YQLv1Antlr4ParserDISTINCT = 108 - YQLv1Antlr4ParserDO = 109 - YQLv1Antlr4ParserDROP = 110 - YQLv1Antlr4ParserEACH = 111 - YQLv1Antlr4ParserELSE = 112 - YQLv1Antlr4ParserEMPTY = 113 - YQLv1Antlr4ParserEMPTY_ACTION = 114 - YQLv1Antlr4ParserENCRYPTED = 115 - YQLv1Antlr4ParserEND = 116 - YQLv1Antlr4ParserENUM = 117 - YQLv1Antlr4ParserERASE = 118 - YQLv1Antlr4ParserERROR = 119 - YQLv1Antlr4ParserESCAPE = 120 - YQLv1Antlr4ParserEVALUATE = 121 - YQLv1Antlr4ParserEXCEPT = 122 - YQLv1Antlr4ParserEXCLUDE = 123 - YQLv1Antlr4ParserEXCLUSION = 124 - YQLv1Antlr4ParserEXCLUSIVE = 125 - YQLv1Antlr4ParserEXISTS = 126 - YQLv1Antlr4ParserEXPLAIN = 127 - YQLv1Antlr4ParserEXPORT = 128 - YQLv1Antlr4ParserEXTERNAL = 129 - YQLv1Antlr4ParserFAIL = 130 - YQLv1Antlr4ParserFALSE = 131 - YQLv1Antlr4ParserFAMILY = 132 - YQLv1Antlr4ParserFILTER = 133 - YQLv1Antlr4ParserFIRST = 134 - YQLv1Antlr4ParserFLATTEN = 135 - YQLv1Antlr4ParserFLOW = 136 - YQLv1Antlr4ParserFOLLOWING = 137 - YQLv1Antlr4ParserFOR = 138 - YQLv1Antlr4ParserFOREIGN = 139 - YQLv1Antlr4ParserFROM = 140 - YQLv1Antlr4ParserFULL = 141 - YQLv1Antlr4ParserFUNCTION = 142 - YQLv1Antlr4ParserGLOB = 143 - YQLv1Antlr4ParserGLOBAL = 144 - YQLv1Antlr4ParserGRANT = 145 - YQLv1Antlr4ParserGROUP = 146 - YQLv1Antlr4ParserGROUPING = 147 - YQLv1Antlr4ParserGROUPS = 148 - YQLv1Antlr4ParserHASH = 149 - YQLv1Antlr4ParserHAVING = 150 - YQLv1Antlr4ParserHOP = 151 - YQLv1Antlr4ParserIF = 152 - YQLv1Antlr4ParserIGNORE = 153 - YQLv1Antlr4ParserILIKE = 154 - YQLv1Antlr4ParserIMMEDIATE = 155 - YQLv1Antlr4ParserIMPORT = 156 - YQLv1Antlr4ParserIN = 157 - YQLv1Antlr4ParserINCREMENT = 158 - YQLv1Antlr4ParserINCREMENTAL = 159 - YQLv1Antlr4ParserINDEX = 160 - YQLv1Antlr4ParserINDEXED = 161 - YQLv1Antlr4ParserINHERITS = 162 - YQLv1Antlr4ParserINITIAL = 163 - YQLv1Antlr4ParserINITIALLY = 164 - YQLv1Antlr4ParserINNER = 165 - YQLv1Antlr4ParserINSERT = 166 - YQLv1Antlr4ParserINSTEAD = 167 - YQLv1Antlr4ParserINTERSECT = 168 - YQLv1Antlr4ParserINTO = 169 - YQLv1Antlr4ParserIS = 170 - YQLv1Antlr4ParserISNULL = 171 - YQLv1Antlr4ParserJOIN = 172 - YQLv1Antlr4ParserJSON_EXISTS = 173 - YQLv1Antlr4ParserJSON_QUERY = 174 - YQLv1Antlr4ParserJSON_VALUE = 175 - YQLv1Antlr4ParserKEY = 176 - YQLv1Antlr4ParserLAST = 177 - YQLv1Antlr4ParserLEFT = 178 - YQLv1Antlr4ParserLEGACY = 179 - YQLv1Antlr4ParserLIKE = 180 - YQLv1Antlr4ParserLIMIT = 181 - YQLv1Antlr4ParserLIST = 182 - YQLv1Antlr4ParserLOCAL = 183 - YQLv1Antlr4ParserLOGIN = 184 - YQLv1Antlr4ParserMANAGE = 185 - YQLv1Antlr4ParserMATCH = 186 - YQLv1Antlr4ParserMATCHES = 187 - YQLv1Antlr4ParserMATCH_RECOGNIZE = 188 - YQLv1Antlr4ParserMEASURES = 189 - YQLv1Antlr4ParserMICROSECONDS = 190 - YQLv1Antlr4ParserMILLISECONDS = 191 - YQLv1Antlr4ParserMODIFY = 192 - YQLv1Antlr4ParserNANOSECONDS = 193 - YQLv1Antlr4ParserNATURAL = 194 - YQLv1Antlr4ParserNEXT = 195 - YQLv1Antlr4ParserNO = 196 - YQLv1Antlr4ParserNOLOGIN = 197 - YQLv1Antlr4ParserNOT = 198 - YQLv1Antlr4ParserNOTNULL = 199 - YQLv1Antlr4ParserNULL = 200 - YQLv1Antlr4ParserNULLS = 201 - YQLv1Antlr4ParserOBJECT = 202 - YQLv1Antlr4ParserOF = 203 - YQLv1Antlr4ParserOFFSET = 204 - YQLv1Antlr4ParserOMIT = 205 - YQLv1Antlr4ParserON = 206 - YQLv1Antlr4ParserONE = 207 - YQLv1Antlr4ParserONLY = 208 - YQLv1Antlr4ParserOPTION = 209 - YQLv1Antlr4ParserOPTIONAL = 210 - YQLv1Antlr4ParserOR = 211 - YQLv1Antlr4ParserORDER = 212 - YQLv1Antlr4ParserOTHERS = 213 - YQLv1Antlr4ParserOUTER = 214 - YQLv1Antlr4ParserOVER = 215 - YQLv1Antlr4ParserPARALLEL = 216 - YQLv1Antlr4ParserPARTITION = 217 - YQLv1Antlr4ParserPASSING = 218 - YQLv1Antlr4ParserPASSWORD = 219 - YQLv1Antlr4ParserPAST = 220 - YQLv1Antlr4ParserPATTERN = 221 - YQLv1Antlr4ParserPER = 222 - YQLv1Antlr4ParserPERMUTE = 223 - YQLv1Antlr4ParserPLAN = 224 - YQLv1Antlr4ParserPOOL = 225 - YQLv1Antlr4ParserPRAGMA = 226 - YQLv1Antlr4ParserPRECEDING = 227 - YQLv1Antlr4ParserPRESORT = 228 - YQLv1Antlr4ParserPRIMARY = 229 - YQLv1Antlr4ParserPRIVILEGES = 230 - YQLv1Antlr4ParserPROCESS = 231 - YQLv1Antlr4ParserQUERY = 232 - YQLv1Antlr4ParserQUEUE = 233 - YQLv1Antlr4ParserRAISE = 234 - YQLv1Antlr4ParserRANGE = 235 - YQLv1Antlr4ParserREDUCE = 236 - YQLv1Antlr4ParserREFERENCES = 237 - YQLv1Antlr4ParserREGEXP = 238 - YQLv1Antlr4ParserREINDEX = 239 - YQLv1Antlr4ParserRELEASE = 240 - YQLv1Antlr4ParserREMOVE = 241 - YQLv1Antlr4ParserRENAME = 242 - YQLv1Antlr4ParserREPEATABLE = 243 - YQLv1Antlr4ParserREPLACE = 244 - YQLv1Antlr4ParserREPLICATION = 245 - YQLv1Antlr4ParserRESET = 246 - YQLv1Antlr4ParserRESOURCE = 247 - YQLv1Antlr4ParserRESPECT = 248 - YQLv1Antlr4ParserRESTART = 249 - YQLv1Antlr4ParserRESTORE = 250 - YQLv1Antlr4ParserRESTRICT = 251 - YQLv1Antlr4ParserRESULT = 252 - YQLv1Antlr4ParserRETURN = 253 - YQLv1Antlr4ParserRETURNING = 254 - YQLv1Antlr4ParserREVERT = 255 - YQLv1Antlr4ParserREVOKE = 256 - YQLv1Antlr4ParserRIGHT = 257 - YQLv1Antlr4ParserRLIKE = 258 - YQLv1Antlr4ParserROLLBACK = 259 - YQLv1Antlr4ParserROLLUP = 260 - YQLv1Antlr4ParserROW = 261 - YQLv1Antlr4ParserROWS = 262 - YQLv1Antlr4ParserSAMPLE = 263 - YQLv1Antlr4ParserSAVEPOINT = 264 - YQLv1Antlr4ParserSCHEMA = 265 - YQLv1Antlr4ParserSECONDS = 266 - YQLv1Antlr4ParserSEEK = 267 - YQLv1Antlr4ParserSELECT = 268 - YQLv1Antlr4ParserSEMI = 269 - YQLv1Antlr4ParserSET = 270 - YQLv1Antlr4ParserSETS = 271 - YQLv1Antlr4ParserSHOW = 272 - YQLv1Antlr4ParserTSKIP = 273 - YQLv1Antlr4ParserSEQUENCE = 274 - YQLv1Antlr4ParserSOURCE = 275 - YQLv1Antlr4ParserSTART = 276 - YQLv1Antlr4ParserSTREAM = 277 - YQLv1Antlr4ParserSTRUCT = 278 - YQLv1Antlr4ParserSUBQUERY = 279 - YQLv1Antlr4ParserSUBSET = 280 - YQLv1Antlr4ParserSYMBOLS = 281 - YQLv1Antlr4ParserSYMMETRIC = 282 - YQLv1Antlr4ParserSYNC = 283 - YQLv1Antlr4ParserSYSTEM = 284 - YQLv1Antlr4ParserTABLE = 285 - YQLv1Antlr4ParserTABLES = 286 - YQLv1Antlr4ParserTABLESAMPLE = 287 - YQLv1Antlr4ParserTABLESTORE = 288 - YQLv1Antlr4ParserTAGGED = 289 - YQLv1Antlr4ParserTEMP = 290 - YQLv1Antlr4ParserTEMPORARY = 291 - YQLv1Antlr4ParserTHEN = 292 - YQLv1Antlr4ParserTIES = 293 - YQLv1Antlr4ParserTO = 294 - YQLv1Antlr4ParserTOPIC = 295 - YQLv1Antlr4ParserTRANSACTION = 296 - YQLv1Antlr4ParserTRIGGER = 297 - YQLv1Antlr4ParserTRUE = 298 - YQLv1Antlr4ParserTUPLE = 299 - YQLv1Antlr4ParserTYPE = 300 - YQLv1Antlr4ParserUNBOUNDED = 301 - YQLv1Antlr4ParserUNCONDITIONAL = 302 - YQLv1Antlr4ParserUNION = 303 - YQLv1Antlr4ParserUNIQUE = 304 - YQLv1Antlr4ParserUNKNOWN = 305 - YQLv1Antlr4ParserUNMATCHED = 306 - YQLv1Antlr4ParserUPDATE = 307 - YQLv1Antlr4ParserUPSERT = 308 - YQLv1Antlr4ParserUSE = 309 - YQLv1Antlr4ParserUSER = 310 - YQLv1Antlr4ParserUSING = 311 - YQLv1Antlr4ParserVACUUM = 312 - YQLv1Antlr4ParserVALUES = 313 - YQLv1Antlr4ParserVARIANT = 314 - YQLv1Antlr4ParserVIEW = 315 - YQLv1Antlr4ParserVIRTUAL = 316 - YQLv1Antlr4ParserWHEN = 317 - YQLv1Antlr4ParserWHERE = 318 - YQLv1Antlr4ParserWINDOW = 319 - YQLv1Antlr4ParserWITH = 320 - YQLv1Antlr4ParserWITHOUT = 321 - YQLv1Antlr4ParserWRAPPER = 322 - YQLv1Antlr4ParserXOR = 323 - YQLv1Antlr4ParserSTRING_VALUE = 324 - YQLv1Antlr4ParserID_PLAIN = 325 - YQLv1Antlr4ParserID_QUOTED = 326 - YQLv1Antlr4ParserDIGITS = 327 - YQLv1Antlr4ParserINTEGER_VALUE = 328 - YQLv1Antlr4ParserREAL = 329 - YQLv1Antlr4ParserBLOB = 330 - YQLv1Antlr4ParserWS = 331 - YQLv1Antlr4ParserCOMMENT = 332 + YQLParserEOF = antlr.TokenEOF + YQLParserEQUALS = 1 + YQLParserEQUALS2 = 2 + YQLParserNOT_EQUALS = 3 + YQLParserNOT_EQUALS2 = 4 + YQLParserLESS = 5 + YQLParserLESS_OR_EQ = 6 + YQLParserGREATER = 7 + YQLParserGREATER_OR_EQ = 8 + YQLParserSHIFT_LEFT = 9 + YQLParserROT_LEFT = 10 + YQLParserAMPERSAND = 11 + YQLParserPIPE = 12 + YQLParserDOUBLE_PIPE = 13 + YQLParserSTRUCT_OPEN = 14 + YQLParserSTRUCT_CLOSE = 15 + YQLParserPLUS = 16 + YQLParserMINUS = 17 + YQLParserTILDA = 18 + YQLParserASTERISK = 19 + YQLParserSLASH = 20 + YQLParserPERCENT = 21 + YQLParserSEMICOLON = 22 + YQLParserDOT = 23 + YQLParserCOMMA = 24 + YQLParserLPAREN = 25 + YQLParserRPAREN = 26 + YQLParserQUESTION = 27 + YQLParserCOLON = 28 + YQLParserCOMMAT = 29 + YQLParserDOLLAR = 30 + YQLParserLBRACE_CURLY = 31 + YQLParserRBRACE_CURLY = 32 + YQLParserCARET = 33 + YQLParserNAMESPACE = 34 + YQLParserARROW = 35 + YQLParserRBRACE_SQUARE = 36 + YQLParserLBRACE_SQUARE = 37 + YQLParserABORT = 38 + YQLParserACTION = 39 + YQLParserADD = 40 + YQLParserAFTER = 41 + YQLParserALL = 42 + YQLParserALTER = 43 + YQLParserANALYZE = 44 + YQLParserAND = 45 + YQLParserANSI = 46 + YQLParserANY = 47 + YQLParserARRAY = 48 + YQLParserAS = 49 + YQLParserASC = 50 + YQLParserASSUME = 51 + YQLParserASYMMETRIC = 52 + YQLParserASYNC = 53 + YQLParserAT = 54 + YQLParserATTACH = 55 + YQLParserATTRIBUTES = 56 + YQLParserAUTOINCREMENT = 57 + YQLParserAUTOMAP = 58 + YQLParserBACKUP = 59 + YQLParserCOLLECTION = 60 + YQLParserBEFORE = 61 + YQLParserBEGIN = 62 + YQLParserBERNOULLI = 63 + YQLParserBETWEEN = 64 + YQLParserBITCAST = 65 + YQLParserBY = 66 + YQLParserCALLABLE = 67 + YQLParserCASCADE = 68 + YQLParserCASE = 69 + YQLParserCAST = 70 + YQLParserCHANGEFEED = 71 + YQLParserCHECK = 72 + YQLParserCLASSIFIER = 73 + YQLParserCOLLATE = 74 + YQLParserCOLUMN = 75 + YQLParserCOLUMNS = 76 + YQLParserCOMMIT = 77 + YQLParserCOMPACT = 78 + YQLParserCONDITIONAL = 79 + YQLParserCONFLICT = 80 + YQLParserCONNECT = 81 + YQLParserCONSTRAINT = 82 + YQLParserCONSUMER = 83 + YQLParserCOVER = 84 + YQLParserCREATE = 85 + YQLParserCROSS = 86 + YQLParserCUBE = 87 + YQLParserCURRENT = 88 + YQLParserCURRENT_DATE = 89 + YQLParserCURRENT_TIME = 90 + YQLParserCURRENT_TIMESTAMP = 91 + YQLParserDATA = 92 + YQLParserDATABASE = 93 + YQLParserDECIMAL = 94 + YQLParserDECLARE = 95 + YQLParserDEFAULT = 96 + YQLParserDEFERRABLE = 97 + YQLParserDEFERRED = 98 + YQLParserDEFINE = 99 + YQLParserDELETE = 100 + YQLParserDESC = 101 + YQLParserDESCRIBE = 102 + YQLParserDETACH = 103 + YQLParserDICT = 104 + YQLParserDIRECTORY = 105 + YQLParserDISABLE = 106 + YQLParserDISCARD = 107 + YQLParserDISTINCT = 108 + YQLParserDO = 109 + YQLParserDROP = 110 + YQLParserEACH = 111 + YQLParserELSE = 112 + YQLParserEMPTY = 113 + YQLParserEMPTY_ACTION = 114 + YQLParserENCRYPTED = 115 + YQLParserEND = 116 + YQLParserENUM = 117 + YQLParserERASE = 118 + YQLParserERROR = 119 + YQLParserESCAPE = 120 + YQLParserEVALUATE = 121 + YQLParserEXCEPT = 122 + YQLParserEXCLUDE = 123 + YQLParserEXCLUSION = 124 + YQLParserEXCLUSIVE = 125 + YQLParserEXISTS = 126 + YQLParserEXPLAIN = 127 + YQLParserEXPORT = 128 + YQLParserEXTERNAL = 129 + YQLParserFAIL = 130 + YQLParserFALSE = 131 + YQLParserFAMILY = 132 + YQLParserFILTER = 133 + YQLParserFIRST = 134 + YQLParserFLATTEN = 135 + YQLParserFLOW = 136 + YQLParserFOLLOWING = 137 + YQLParserFOR = 138 + YQLParserFOREIGN = 139 + YQLParserFROM = 140 + YQLParserFULL = 141 + YQLParserFUNCTION = 142 + YQLParserGLOB = 143 + YQLParserGLOBAL = 144 + YQLParserGRANT = 145 + YQLParserGROUP = 146 + YQLParserGROUPING = 147 + YQLParserGROUPS = 148 + YQLParserHASH = 149 + YQLParserHAVING = 150 + YQLParserHOP = 151 + YQLParserIF = 152 + YQLParserIGNORE = 153 + YQLParserILIKE = 154 + YQLParserIMMEDIATE = 155 + YQLParserIMPORT = 156 + YQLParserIN = 157 + YQLParserINCREMENT = 158 + YQLParserINCREMENTAL = 159 + YQLParserINDEX = 160 + YQLParserINDEXED = 161 + YQLParserINHERITS = 162 + YQLParserINITIAL = 163 + YQLParserINITIALLY = 164 + YQLParserINNER = 165 + YQLParserINSERT = 166 + YQLParserINSTEAD = 167 + YQLParserINTERSECT = 168 + YQLParserINTO = 169 + YQLParserIS = 170 + YQLParserISNULL = 171 + YQLParserJOIN = 172 + YQLParserJSON_EXISTS = 173 + YQLParserJSON_QUERY = 174 + YQLParserJSON_VALUE = 175 + YQLParserKEY = 176 + YQLParserLAST = 177 + YQLParserLEFT = 178 + YQLParserLEGACY = 179 + YQLParserLIKE = 180 + YQLParserLIMIT = 181 + YQLParserLIST = 182 + YQLParserLOCAL = 183 + YQLParserLOGIN = 184 + YQLParserMANAGE = 185 + YQLParserMATCH = 186 + YQLParserMATCHES = 187 + YQLParserMATCH_RECOGNIZE = 188 + YQLParserMEASURES = 189 + YQLParserMICROSECONDS = 190 + YQLParserMILLISECONDS = 191 + YQLParserMODIFY = 192 + YQLParserNANOSECONDS = 193 + YQLParserNATURAL = 194 + YQLParserNEXT = 195 + YQLParserNO = 196 + YQLParserNOLOGIN = 197 + YQLParserNOT = 198 + YQLParserNOTNULL = 199 + YQLParserNULL = 200 + YQLParserNULLS = 201 + YQLParserOBJECT = 202 + YQLParserOF = 203 + YQLParserOFFSET = 204 + YQLParserOMIT = 205 + YQLParserON = 206 + YQLParserONE = 207 + YQLParserONLY = 208 + YQLParserOPTION = 209 + YQLParserOPTIONAL = 210 + YQLParserOR = 211 + YQLParserORDER = 212 + YQLParserOTHERS = 213 + YQLParserOUTER = 214 + YQLParserOVER = 215 + YQLParserPARALLEL = 216 + YQLParserPARTITION = 217 + YQLParserPASSING = 218 + YQLParserPASSWORD = 219 + YQLParserPAST = 220 + YQLParserPATTERN = 221 + YQLParserPER = 222 + YQLParserPERMUTE = 223 + YQLParserPLAN = 224 + YQLParserPOOL = 225 + YQLParserPRAGMA = 226 + YQLParserPRECEDING = 227 + YQLParserPRESORT = 228 + YQLParserPRIMARY = 229 + YQLParserPRIVILEGES = 230 + YQLParserPROCESS = 231 + YQLParserQUERY = 232 + YQLParserQUEUE = 233 + YQLParserRAISE = 234 + YQLParserRANGE = 235 + YQLParserREDUCE = 236 + YQLParserREFERENCES = 237 + YQLParserREGEXP = 238 + YQLParserREINDEX = 239 + YQLParserRELEASE = 240 + YQLParserREMOVE = 241 + YQLParserRENAME = 242 + YQLParserREPEATABLE = 243 + YQLParserREPLACE = 244 + YQLParserREPLICATION = 245 + YQLParserRESET = 246 + YQLParserRESOURCE = 247 + YQLParserRESPECT = 248 + YQLParserRESTART = 249 + YQLParserRESTORE = 250 + YQLParserRESTRICT = 251 + YQLParserRESULT = 252 + YQLParserRETURN = 253 + YQLParserRETURNING = 254 + YQLParserREVERT = 255 + YQLParserREVOKE = 256 + YQLParserRIGHT = 257 + YQLParserRLIKE = 258 + YQLParserROLLBACK = 259 + YQLParserROLLUP = 260 + YQLParserROW = 261 + YQLParserROWS = 262 + YQLParserSAMPLE = 263 + YQLParserSAVEPOINT = 264 + YQLParserSCHEMA = 265 + YQLParserSECONDS = 266 + YQLParserSEEK = 267 + YQLParserSELECT = 268 + YQLParserSEMI = 269 + YQLParserSET = 270 + YQLParserSETS = 271 + YQLParserSHOW = 272 + YQLParserTSKIP = 273 + YQLParserSEQUENCE = 274 + YQLParserSOURCE = 275 + YQLParserSTART = 276 + YQLParserSTREAM = 277 + YQLParserSTRUCT = 278 + YQLParserSUBQUERY = 279 + YQLParserSUBSET = 280 + YQLParserSYMBOLS = 281 + YQLParserSYMMETRIC = 282 + YQLParserSYNC = 283 + YQLParserSYSTEM = 284 + YQLParserTABLE = 285 + YQLParserTABLES = 286 + YQLParserTABLESAMPLE = 287 + YQLParserTABLESTORE = 288 + YQLParserTAGGED = 289 + YQLParserTEMP = 290 + YQLParserTEMPORARY = 291 + YQLParserTHEN = 292 + YQLParserTIES = 293 + YQLParserTO = 294 + YQLParserTOPIC = 295 + YQLParserTRANSACTION = 296 + YQLParserTRIGGER = 297 + YQLParserTRUE = 298 + YQLParserTUPLE = 299 + YQLParserTYPE = 300 + YQLParserUNBOUNDED = 301 + YQLParserUNCONDITIONAL = 302 + YQLParserUNION = 303 + YQLParserUNIQUE = 304 + YQLParserUNKNOWN = 305 + YQLParserUNMATCHED = 306 + YQLParserUPDATE = 307 + YQLParserUPSERT = 308 + YQLParserUSE = 309 + YQLParserUSER = 310 + YQLParserUSING = 311 + YQLParserVACUUM = 312 + YQLParserVALUES = 313 + YQLParserVARIANT = 314 + YQLParserVIEW = 315 + YQLParserVIRTUAL = 316 + YQLParserWHEN = 317 + YQLParserWHERE = 318 + YQLParserWINDOW = 319 + YQLParserWITH = 320 + YQLParserWITHOUT = 321 + YQLParserWRAPPER = 322 + YQLParserXOR = 323 + YQLParserSTRING_VALUE = 324 + YQLParserID_PLAIN = 325 + YQLParserID_QUOTED = 326 + YQLParserDIGITS = 327 + YQLParserINTEGER_VALUE = 328 + YQLParserREAL = 329 + YQLParserBLOB = 330 + YQLParserWS = 331 + YQLParserCOMMENT = 332 ) -// YQLv1Antlr4Parser rules. +// YQLParser rules. const ( - YQLv1Antlr4ParserRULE_sql_query = 0 - YQLv1Antlr4ParserRULE_sql_stmt_list = 1 - YQLv1Antlr4ParserRULE_ansi_sql_stmt_list = 2 - YQLv1Antlr4ParserRULE_lambda_body = 3 - YQLv1Antlr4ParserRULE_lambda_stmt = 4 - YQLv1Antlr4ParserRULE_sql_stmt = 5 - YQLv1Antlr4ParserRULE_sql_stmt_core = 6 - YQLv1Antlr4ParserRULE_expr = 7 - YQLv1Antlr4ParserRULE_or_subexpr = 8 - YQLv1Antlr4ParserRULE_and_subexpr = 9 - YQLv1Antlr4ParserRULE_xor_subexpr = 10 - YQLv1Antlr4ParserRULE_distinct_from_op = 11 - YQLv1Antlr4ParserRULE_cond_expr = 12 - YQLv1Antlr4ParserRULE_match_op = 13 - YQLv1Antlr4ParserRULE_eq_subexpr = 14 - YQLv1Antlr4ParserRULE_shift_right = 15 - YQLv1Antlr4ParserRULE_rot_right = 16 - YQLv1Antlr4ParserRULE_double_question = 17 - YQLv1Antlr4ParserRULE_neq_subexpr = 18 - YQLv1Antlr4ParserRULE_bit_subexpr = 19 - YQLv1Antlr4ParserRULE_add_subexpr = 20 - YQLv1Antlr4ParserRULE_mul_subexpr = 21 - YQLv1Antlr4ParserRULE_con_subexpr = 22 - YQLv1Antlr4ParserRULE_unary_op = 23 - YQLv1Antlr4ParserRULE_unary_subexpr_suffix = 24 - YQLv1Antlr4ParserRULE_unary_casual_subexpr = 25 - YQLv1Antlr4ParserRULE_in_unary_casual_subexpr = 26 - YQLv1Antlr4ParserRULE_unary_subexpr = 27 - YQLv1Antlr4ParserRULE_in_unary_subexpr = 28 - YQLv1Antlr4ParserRULE_list_literal = 29 - YQLv1Antlr4ParserRULE_expr_dict_list = 30 - YQLv1Antlr4ParserRULE_dict_literal = 31 - YQLv1Antlr4ParserRULE_expr_struct_list = 32 - YQLv1Antlr4ParserRULE_struct_literal = 33 - YQLv1Antlr4ParserRULE_atom_expr = 34 - YQLv1Antlr4ParserRULE_in_atom_expr = 35 - YQLv1Antlr4ParserRULE_cast_expr = 36 - YQLv1Antlr4ParserRULE_bitcast_expr = 37 - YQLv1Antlr4ParserRULE_exists_expr = 38 - YQLv1Antlr4ParserRULE_case_expr = 39 - YQLv1Antlr4ParserRULE_lambda = 40 - YQLv1Antlr4ParserRULE_in_expr = 41 - YQLv1Antlr4ParserRULE_json_api_expr = 42 - YQLv1Antlr4ParserRULE_jsonpath_spec = 43 - YQLv1Antlr4ParserRULE_json_variable_name = 44 - YQLv1Antlr4ParserRULE_json_variable = 45 - YQLv1Antlr4ParserRULE_json_variables = 46 - YQLv1Antlr4ParserRULE_json_common_args = 47 - YQLv1Antlr4ParserRULE_json_case_handler = 48 - YQLv1Antlr4ParserRULE_json_value = 49 - YQLv1Antlr4ParserRULE_json_exists_handler = 50 - YQLv1Antlr4ParserRULE_json_exists = 51 - YQLv1Antlr4ParserRULE_json_query_wrapper = 52 - YQLv1Antlr4ParserRULE_json_query_handler = 53 - YQLv1Antlr4ParserRULE_json_query = 54 - YQLv1Antlr4ParserRULE_smart_parenthesis = 55 - YQLv1Antlr4ParserRULE_expr_list = 56 - YQLv1Antlr4ParserRULE_pure_column_list = 57 - YQLv1Antlr4ParserRULE_pure_column_or_named = 58 - YQLv1Antlr4ParserRULE_pure_column_or_named_list = 59 - YQLv1Antlr4ParserRULE_column_name = 60 - YQLv1Antlr4ParserRULE_without_column_name = 61 - YQLv1Antlr4ParserRULE_column_list = 62 - YQLv1Antlr4ParserRULE_without_column_list = 63 - YQLv1Antlr4ParserRULE_named_expr = 64 - YQLv1Antlr4ParserRULE_named_expr_list = 65 - YQLv1Antlr4ParserRULE_invoke_expr = 66 - YQLv1Antlr4ParserRULE_invoke_expr_tail = 67 - YQLv1Antlr4ParserRULE_using_call_expr = 68 - YQLv1Antlr4ParserRULE_key_expr = 69 - YQLv1Antlr4ParserRULE_when_expr = 70 - YQLv1Antlr4ParserRULE_literal_value = 71 - YQLv1Antlr4ParserRULE_bind_parameter = 72 - YQLv1Antlr4ParserRULE_opt_bind_parameter = 73 - YQLv1Antlr4ParserRULE_bind_parameter_list = 74 - YQLv1Antlr4ParserRULE_named_bind_parameter = 75 - YQLv1Antlr4ParserRULE_named_bind_parameter_list = 76 - YQLv1Antlr4ParserRULE_signed_number = 77 - YQLv1Antlr4ParserRULE_type_name_simple = 78 - YQLv1Antlr4ParserRULE_integer_or_bind = 79 - YQLv1Antlr4ParserRULE_type_name_tag = 80 - YQLv1Antlr4ParserRULE_struct_arg = 81 - YQLv1Antlr4ParserRULE_struct_arg_positional = 82 - YQLv1Antlr4ParserRULE_variant_arg = 83 - YQLv1Antlr4ParserRULE_callable_arg = 84 - YQLv1Antlr4ParserRULE_callable_arg_list = 85 - YQLv1Antlr4ParserRULE_type_name_decimal = 86 - YQLv1Antlr4ParserRULE_type_name_optional = 87 - YQLv1Antlr4ParserRULE_type_name_tuple = 88 - YQLv1Antlr4ParserRULE_type_name_struct = 89 - YQLv1Antlr4ParserRULE_type_name_variant = 90 - YQLv1Antlr4ParserRULE_type_name_list = 91 - YQLv1Antlr4ParserRULE_type_name_stream = 92 - YQLv1Antlr4ParserRULE_type_name_flow = 93 - YQLv1Antlr4ParserRULE_type_name_dict = 94 - YQLv1Antlr4ParserRULE_type_name_set = 95 - YQLv1Antlr4ParserRULE_type_name_enum = 96 - YQLv1Antlr4ParserRULE_type_name_resource = 97 - YQLv1Antlr4ParserRULE_type_name_tagged = 98 - YQLv1Antlr4ParserRULE_type_name_callable = 99 - YQLv1Antlr4ParserRULE_type_name_composite = 100 - YQLv1Antlr4ParserRULE_type_name = 101 - YQLv1Antlr4ParserRULE_type_name_or_bind = 102 - YQLv1Antlr4ParserRULE_value_constructor_literal = 103 - YQLv1Antlr4ParserRULE_value_constructor = 104 - YQLv1Antlr4ParserRULE_declare_stmt = 105 - YQLv1Antlr4ParserRULE_module_path = 106 - YQLv1Antlr4ParserRULE_import_stmt = 107 - YQLv1Antlr4ParserRULE_export_stmt = 108 - YQLv1Antlr4ParserRULE_call_action = 109 - YQLv1Antlr4ParserRULE_inline_action = 110 - YQLv1Antlr4ParserRULE_do_stmt = 111 - YQLv1Antlr4ParserRULE_pragma_stmt = 112 - YQLv1Antlr4ParserRULE_pragma_value = 113 - YQLv1Antlr4ParserRULE_sort_specification = 114 - YQLv1Antlr4ParserRULE_sort_specification_list = 115 - YQLv1Antlr4ParserRULE_select_stmt = 116 - YQLv1Antlr4ParserRULE_select_unparenthesized_stmt = 117 - YQLv1Antlr4ParserRULE_select_kind_parenthesis = 118 - YQLv1Antlr4ParserRULE_select_op = 119 - YQLv1Antlr4ParserRULE_select_kind_partial = 120 - YQLv1Antlr4ParserRULE_select_kind = 121 - YQLv1Antlr4ParserRULE_process_core = 122 - YQLv1Antlr4ParserRULE_external_call_param = 123 - YQLv1Antlr4ParserRULE_external_call_settings = 124 - YQLv1Antlr4ParserRULE_reduce_core = 125 - YQLv1Antlr4ParserRULE_opt_set_quantifier = 126 - YQLv1Antlr4ParserRULE_select_core = 127 - YQLv1Antlr4ParserRULE_row_pattern_recognition_clause = 128 - YQLv1Antlr4ParserRULE_row_pattern_rows_per_match = 129 - YQLv1Antlr4ParserRULE_row_pattern_empty_match_handling = 130 - YQLv1Antlr4ParserRULE_row_pattern_measures = 131 - YQLv1Antlr4ParserRULE_row_pattern_measure_list = 132 - YQLv1Antlr4ParserRULE_row_pattern_measure_definition = 133 - YQLv1Antlr4ParserRULE_row_pattern_common_syntax = 134 - YQLv1Antlr4ParserRULE_row_pattern_skip_to = 135 - YQLv1Antlr4ParserRULE_row_pattern_skip_to_variable_name = 136 - YQLv1Antlr4ParserRULE_row_pattern_initial_or_seek = 137 - YQLv1Antlr4ParserRULE_row_pattern = 138 - YQLv1Antlr4ParserRULE_row_pattern_term = 139 - YQLv1Antlr4ParserRULE_row_pattern_factor = 140 - YQLv1Antlr4ParserRULE_row_pattern_quantifier = 141 - YQLv1Antlr4ParserRULE_row_pattern_primary = 142 - YQLv1Antlr4ParserRULE_row_pattern_primary_variable_name = 143 - YQLv1Antlr4ParserRULE_row_pattern_permute = 144 - YQLv1Antlr4ParserRULE_row_pattern_subset_clause = 145 - YQLv1Antlr4ParserRULE_row_pattern_subset_list = 146 - YQLv1Antlr4ParserRULE_row_pattern_subset_item = 147 - YQLv1Antlr4ParserRULE_row_pattern_subset_item_variable_name = 148 - YQLv1Antlr4ParserRULE_row_pattern_subset_rhs = 149 - YQLv1Antlr4ParserRULE_row_pattern_subset_rhs_variable_name = 150 - YQLv1Antlr4ParserRULE_row_pattern_definition_list = 151 - YQLv1Antlr4ParserRULE_row_pattern_definition = 152 - YQLv1Antlr4ParserRULE_row_pattern_definition_variable_name = 153 - YQLv1Antlr4ParserRULE_row_pattern_definition_search_condition = 154 - YQLv1Antlr4ParserRULE_search_condition = 155 - YQLv1Antlr4ParserRULE_row_pattern_variable_name = 156 - YQLv1Antlr4ParserRULE_order_by_clause = 157 - YQLv1Antlr4ParserRULE_ext_order_by_clause = 158 - YQLv1Antlr4ParserRULE_group_by_clause = 159 - YQLv1Antlr4ParserRULE_grouping_element_list = 160 - YQLv1Antlr4ParserRULE_grouping_element = 161 - YQLv1Antlr4ParserRULE_ordinary_grouping_set = 162 - YQLv1Antlr4ParserRULE_ordinary_grouping_set_list = 163 - YQLv1Antlr4ParserRULE_rollup_list = 164 - YQLv1Antlr4ParserRULE_cube_list = 165 - YQLv1Antlr4ParserRULE_grouping_sets_specification = 166 - YQLv1Antlr4ParserRULE_hopping_window_specification = 167 - YQLv1Antlr4ParserRULE_result_column = 168 - YQLv1Antlr4ParserRULE_join_source = 169 - YQLv1Antlr4ParserRULE_named_column = 170 - YQLv1Antlr4ParserRULE_flatten_by_arg = 171 - YQLv1Antlr4ParserRULE_flatten_source = 172 - YQLv1Antlr4ParserRULE_named_single_source = 173 - YQLv1Antlr4ParserRULE_single_source = 174 - YQLv1Antlr4ParserRULE_sample_clause = 175 - YQLv1Antlr4ParserRULE_tablesample_clause = 176 - YQLv1Antlr4ParserRULE_sampling_mode = 177 - YQLv1Antlr4ParserRULE_repeatable_clause = 178 - YQLv1Antlr4ParserRULE_join_op = 179 - YQLv1Antlr4ParserRULE_join_constraint = 180 - YQLv1Antlr4ParserRULE_returning_columns_list = 181 - YQLv1Antlr4ParserRULE_into_table_stmt = 182 - YQLv1Antlr4ParserRULE_into_values_source = 183 - YQLv1Antlr4ParserRULE_values_stmt = 184 - YQLv1Antlr4ParserRULE_values_source = 185 - YQLv1Antlr4ParserRULE_values_source_row_list = 186 - YQLv1Antlr4ParserRULE_values_source_row = 187 - YQLv1Antlr4ParserRULE_simple_values_source = 188 - YQLv1Antlr4ParserRULE_create_external_data_source_stmt = 189 - YQLv1Antlr4ParserRULE_alter_external_data_source_stmt = 190 - YQLv1Antlr4ParserRULE_alter_external_data_source_action = 191 - YQLv1Antlr4ParserRULE_drop_external_data_source_stmt = 192 - YQLv1Antlr4ParserRULE_create_view_stmt = 193 - YQLv1Antlr4ParserRULE_drop_view_stmt = 194 - YQLv1Antlr4ParserRULE_upsert_object_stmt = 195 - YQLv1Antlr4ParserRULE_create_object_stmt = 196 - YQLv1Antlr4ParserRULE_create_object_features = 197 - YQLv1Antlr4ParserRULE_alter_object_stmt = 198 - YQLv1Antlr4ParserRULE_alter_object_features = 199 - YQLv1Antlr4ParserRULE_drop_object_stmt = 200 - YQLv1Antlr4ParserRULE_drop_object_features = 201 - YQLv1Antlr4ParserRULE_object_feature_value = 202 - YQLv1Antlr4ParserRULE_object_feature_kv = 203 - YQLv1Antlr4ParserRULE_object_feature_flag = 204 - YQLv1Antlr4ParserRULE_object_feature = 205 - YQLv1Antlr4ParserRULE_object_features = 206 - YQLv1Antlr4ParserRULE_object_type_ref = 207 - YQLv1Antlr4ParserRULE_create_table_stmt = 208 - YQLv1Antlr4ParserRULE_create_table_entry = 209 - YQLv1Antlr4ParserRULE_create_backup_collection_stmt = 210 - YQLv1Antlr4ParserRULE_alter_backup_collection_stmt = 211 - YQLv1Antlr4ParserRULE_drop_backup_collection_stmt = 212 - YQLv1Antlr4ParserRULE_create_backup_collection_entries = 213 - YQLv1Antlr4ParserRULE_create_backup_collection_entries_many = 214 - YQLv1Antlr4ParserRULE_table_list = 215 - YQLv1Antlr4ParserRULE_alter_backup_collection_actions = 216 - YQLv1Antlr4ParserRULE_alter_backup_collection_action = 217 - YQLv1Antlr4ParserRULE_alter_backup_collection_entries = 218 - YQLv1Antlr4ParserRULE_alter_backup_collection_entry = 219 - YQLv1Antlr4ParserRULE_backup_collection = 220 - YQLv1Antlr4ParserRULE_backup_collection_settings = 221 - YQLv1Antlr4ParserRULE_backup_collection_settings_entry = 222 - YQLv1Antlr4ParserRULE_backup_stmt = 223 - YQLv1Antlr4ParserRULE_restore_stmt = 224 - YQLv1Antlr4ParserRULE_table_inherits = 225 - YQLv1Antlr4ParserRULE_table_partition_by = 226 - YQLv1Antlr4ParserRULE_with_table_settings = 227 - YQLv1Antlr4ParserRULE_table_tablestore = 228 - YQLv1Antlr4ParserRULE_table_settings_entry = 229 - YQLv1Antlr4ParserRULE_table_as_source = 230 - YQLv1Antlr4ParserRULE_alter_table_stmt = 231 - YQLv1Antlr4ParserRULE_alter_table_action = 232 - YQLv1Antlr4ParserRULE_alter_external_table_stmt = 233 - YQLv1Antlr4ParserRULE_alter_external_table_action = 234 - YQLv1Antlr4ParserRULE_alter_table_store_stmt = 235 - YQLv1Antlr4ParserRULE_alter_table_store_action = 236 - YQLv1Antlr4ParserRULE_alter_table_add_column = 237 - YQLv1Antlr4ParserRULE_alter_table_drop_column = 238 - YQLv1Antlr4ParserRULE_alter_table_alter_column = 239 - YQLv1Antlr4ParserRULE_alter_table_alter_column_drop_not_null = 240 - YQLv1Antlr4ParserRULE_alter_table_add_column_family = 241 - YQLv1Antlr4ParserRULE_alter_table_alter_column_family = 242 - YQLv1Antlr4ParserRULE_alter_table_set_table_setting_uncompat = 243 - YQLv1Antlr4ParserRULE_alter_table_set_table_setting_compat = 244 - YQLv1Antlr4ParserRULE_alter_table_reset_table_setting = 245 - YQLv1Antlr4ParserRULE_alter_table_add_index = 246 - YQLv1Antlr4ParserRULE_alter_table_drop_index = 247 - YQLv1Antlr4ParserRULE_alter_table_rename_to = 248 - YQLv1Antlr4ParserRULE_alter_table_rename_index_to = 249 - YQLv1Antlr4ParserRULE_alter_table_add_changefeed = 250 - YQLv1Antlr4ParserRULE_alter_table_alter_changefeed = 251 - YQLv1Antlr4ParserRULE_alter_table_drop_changefeed = 252 - YQLv1Antlr4ParserRULE_alter_table_alter_index = 253 - YQLv1Antlr4ParserRULE_column_schema = 254 - YQLv1Antlr4ParserRULE_family_relation = 255 - YQLv1Antlr4ParserRULE_opt_column_constraints = 256 - YQLv1Antlr4ParserRULE_column_order_by_specification = 257 - YQLv1Antlr4ParserRULE_table_constraint = 258 - YQLv1Antlr4ParserRULE_table_index = 259 - YQLv1Antlr4ParserRULE_table_index_type = 260 - YQLv1Antlr4ParserRULE_global_index = 261 - YQLv1Antlr4ParserRULE_local_index = 262 - YQLv1Antlr4ParserRULE_index_subtype = 263 - YQLv1Antlr4ParserRULE_with_index_settings = 264 - YQLv1Antlr4ParserRULE_index_setting_entry = 265 - YQLv1Antlr4ParserRULE_index_setting_value = 266 - YQLv1Antlr4ParserRULE_changefeed = 267 - YQLv1Antlr4ParserRULE_changefeed_settings = 268 - YQLv1Antlr4ParserRULE_changefeed_settings_entry = 269 - YQLv1Antlr4ParserRULE_changefeed_setting_value = 270 - YQLv1Antlr4ParserRULE_changefeed_alter_settings = 271 - YQLv1Antlr4ParserRULE_alter_table_setting_entry = 272 - YQLv1Antlr4ParserRULE_table_setting_value = 273 - YQLv1Antlr4ParserRULE_ttl_tier_list = 274 - YQLv1Antlr4ParserRULE_ttl_tier_action = 275 - YQLv1Antlr4ParserRULE_family_entry = 276 - YQLv1Antlr4ParserRULE_family_settings = 277 - YQLv1Antlr4ParserRULE_family_settings_entry = 278 - YQLv1Antlr4ParserRULE_family_setting_value = 279 - YQLv1Antlr4ParserRULE_split_boundaries = 280 - YQLv1Antlr4ParserRULE_literal_value_list = 281 - YQLv1Antlr4ParserRULE_alter_table_alter_index_action = 282 - YQLv1Antlr4ParserRULE_drop_table_stmt = 283 - YQLv1Antlr4ParserRULE_create_user_stmt = 284 - YQLv1Antlr4ParserRULE_alter_user_stmt = 285 - YQLv1Antlr4ParserRULE_create_group_stmt = 286 - YQLv1Antlr4ParserRULE_alter_group_stmt = 287 - YQLv1Antlr4ParserRULE_drop_role_stmt = 288 - YQLv1Antlr4ParserRULE_role_name = 289 - YQLv1Antlr4ParserRULE_create_user_option = 290 - YQLv1Antlr4ParserRULE_password_option = 291 - YQLv1Antlr4ParserRULE_login_option = 292 - YQLv1Antlr4ParserRULE_grant_permissions_stmt = 293 - YQLv1Antlr4ParserRULE_revoke_permissions_stmt = 294 - YQLv1Antlr4ParserRULE_permission_id = 295 - YQLv1Antlr4ParserRULE_permission_name = 296 - YQLv1Antlr4ParserRULE_permission_name_target = 297 - YQLv1Antlr4ParserRULE_create_resource_pool_stmt = 298 - YQLv1Antlr4ParserRULE_alter_resource_pool_stmt = 299 - YQLv1Antlr4ParserRULE_alter_resource_pool_action = 300 - YQLv1Antlr4ParserRULE_drop_resource_pool_stmt = 301 - YQLv1Antlr4ParserRULE_create_resource_pool_classifier_stmt = 302 - YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_stmt = 303 - YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_action = 304 - YQLv1Antlr4ParserRULE_drop_resource_pool_classifier_stmt = 305 - YQLv1Antlr4ParserRULE_create_replication_stmt = 306 - YQLv1Antlr4ParserRULE_replication_target = 307 - YQLv1Antlr4ParserRULE_replication_settings = 308 - YQLv1Antlr4ParserRULE_replication_settings_entry = 309 - YQLv1Antlr4ParserRULE_alter_replication_stmt = 310 - YQLv1Antlr4ParserRULE_alter_replication_action = 311 - YQLv1Antlr4ParserRULE_alter_replication_set_setting = 312 - YQLv1Antlr4ParserRULE_drop_replication_stmt = 313 - YQLv1Antlr4ParserRULE_action_or_subquery_args = 314 - YQLv1Antlr4ParserRULE_define_action_or_subquery_stmt = 315 - YQLv1Antlr4ParserRULE_define_action_or_subquery_body = 316 - YQLv1Antlr4ParserRULE_if_stmt = 317 - YQLv1Antlr4ParserRULE_for_stmt = 318 - YQLv1Antlr4ParserRULE_table_ref = 319 - YQLv1Antlr4ParserRULE_table_key = 320 - YQLv1Antlr4ParserRULE_table_arg = 321 - YQLv1Antlr4ParserRULE_table_hints = 322 - YQLv1Antlr4ParserRULE_table_hint = 323 - YQLv1Antlr4ParserRULE_object_ref = 324 - YQLv1Antlr4ParserRULE_simple_table_ref_core = 325 - YQLv1Antlr4ParserRULE_simple_table_ref = 326 - YQLv1Antlr4ParserRULE_into_simple_table_ref = 327 - YQLv1Antlr4ParserRULE_delete_stmt = 328 - YQLv1Antlr4ParserRULE_update_stmt = 329 - YQLv1Antlr4ParserRULE_set_clause_choice = 330 - YQLv1Antlr4ParserRULE_set_clause_list = 331 - YQLv1Antlr4ParserRULE_set_clause = 332 - YQLv1Antlr4ParserRULE_set_target = 333 - YQLv1Antlr4ParserRULE_multiple_column_assignment = 334 - YQLv1Antlr4ParserRULE_set_target_list = 335 - YQLv1Antlr4ParserRULE_create_topic_stmt = 336 - YQLv1Antlr4ParserRULE_create_topic_entries = 337 - YQLv1Antlr4ParserRULE_create_topic_entry = 338 - YQLv1Antlr4ParserRULE_with_topic_settings = 339 - YQLv1Antlr4ParserRULE_alter_topic_stmt = 340 - YQLv1Antlr4ParserRULE_alter_topic_action = 341 - YQLv1Antlr4ParserRULE_alter_topic_add_consumer = 342 - YQLv1Antlr4ParserRULE_topic_create_consumer_entry = 343 - YQLv1Antlr4ParserRULE_alter_topic_alter_consumer = 344 - YQLv1Antlr4ParserRULE_alter_topic_alter_consumer_entry = 345 - YQLv1Antlr4ParserRULE_alter_topic_drop_consumer = 346 - YQLv1Antlr4ParserRULE_topic_alter_consumer_set = 347 - YQLv1Antlr4ParserRULE_topic_alter_consumer_reset = 348 - YQLv1Antlr4ParserRULE_alter_topic_set_settings = 349 - YQLv1Antlr4ParserRULE_alter_topic_reset_settings = 350 - YQLv1Antlr4ParserRULE_drop_topic_stmt = 351 - YQLv1Antlr4ParserRULE_topic_settings = 352 - YQLv1Antlr4ParserRULE_topic_settings_entry = 353 - YQLv1Antlr4ParserRULE_topic_setting_value = 354 - YQLv1Antlr4ParserRULE_topic_consumer_with_settings = 355 - YQLv1Antlr4ParserRULE_topic_consumer_settings = 356 - YQLv1Antlr4ParserRULE_topic_consumer_settings_entry = 357 - YQLv1Antlr4ParserRULE_topic_consumer_setting_value = 358 - YQLv1Antlr4ParserRULE_topic_ref = 359 - YQLv1Antlr4ParserRULE_topic_consumer_ref = 360 - YQLv1Antlr4ParserRULE_null_treatment = 361 - YQLv1Antlr4ParserRULE_filter_clause = 362 - YQLv1Antlr4ParserRULE_window_name_or_specification = 363 - YQLv1Antlr4ParserRULE_window_name = 364 - YQLv1Antlr4ParserRULE_window_clause = 365 - YQLv1Antlr4ParserRULE_window_definition_list = 366 - YQLv1Antlr4ParserRULE_window_definition = 367 - YQLv1Antlr4ParserRULE_new_window_name = 368 - YQLv1Antlr4ParserRULE_window_specification = 369 - YQLv1Antlr4ParserRULE_window_specification_details = 370 - YQLv1Antlr4ParserRULE_existing_window_name = 371 - YQLv1Antlr4ParserRULE_window_partition_clause = 372 - YQLv1Antlr4ParserRULE_window_order_clause = 373 - YQLv1Antlr4ParserRULE_window_frame_clause = 374 - YQLv1Antlr4ParserRULE_window_frame_units = 375 - YQLv1Antlr4ParserRULE_window_frame_extent = 376 - YQLv1Antlr4ParserRULE_window_frame_between = 377 - YQLv1Antlr4ParserRULE_window_frame_bound = 378 - YQLv1Antlr4ParserRULE_window_frame_exclusion = 379 - YQLv1Antlr4ParserRULE_use_stmt = 380 - YQLv1Antlr4ParserRULE_subselect_stmt = 381 - YQLv1Antlr4ParserRULE_named_nodes_stmt = 382 - YQLv1Antlr4ParserRULE_commit_stmt = 383 - YQLv1Antlr4ParserRULE_rollback_stmt = 384 - YQLv1Antlr4ParserRULE_analyze_table = 385 - YQLv1Antlr4ParserRULE_analyze_table_list = 386 - YQLv1Antlr4ParserRULE_analyze_stmt = 387 - YQLv1Antlr4ParserRULE_alter_sequence_stmt = 388 - YQLv1Antlr4ParserRULE_alter_sequence_action = 389 - YQLv1Antlr4ParserRULE_identifier = 390 - YQLv1Antlr4ParserRULE_id = 391 - YQLv1Antlr4ParserRULE_id_schema = 392 - YQLv1Antlr4ParserRULE_id_expr = 393 - YQLv1Antlr4ParserRULE_id_expr_in = 394 - YQLv1Antlr4ParserRULE_id_window = 395 - YQLv1Antlr4ParserRULE_id_table = 396 - YQLv1Antlr4ParserRULE_id_without = 397 - YQLv1Antlr4ParserRULE_id_hint = 398 - YQLv1Antlr4ParserRULE_id_as_compat = 399 - YQLv1Antlr4ParserRULE_an_id = 400 - YQLv1Antlr4ParserRULE_an_id_or_type = 401 - YQLv1Antlr4ParserRULE_an_id_schema = 402 - YQLv1Antlr4ParserRULE_an_id_expr = 403 - YQLv1Antlr4ParserRULE_an_id_expr_in = 404 - YQLv1Antlr4ParserRULE_an_id_window = 405 - YQLv1Antlr4ParserRULE_an_id_table = 406 - YQLv1Antlr4ParserRULE_an_id_without = 407 - YQLv1Antlr4ParserRULE_an_id_hint = 408 - YQLv1Antlr4ParserRULE_an_id_pure = 409 - YQLv1Antlr4ParserRULE_an_id_as_compat = 410 - YQLv1Antlr4ParserRULE_view_name = 411 - YQLv1Antlr4ParserRULE_opt_id_prefix = 412 - YQLv1Antlr4ParserRULE_cluster_expr = 413 - YQLv1Antlr4ParserRULE_id_or_type = 414 - YQLv1Antlr4ParserRULE_opt_id_prefix_or_type = 415 - YQLv1Antlr4ParserRULE_id_or_at = 416 - YQLv1Antlr4ParserRULE_id_table_or_type = 417 - YQLv1Antlr4ParserRULE_id_table_or_at = 418 - YQLv1Antlr4ParserRULE_keyword = 419 - YQLv1Antlr4ParserRULE_keyword_expr_uncompat = 420 - YQLv1Antlr4ParserRULE_keyword_table_uncompat = 421 - YQLv1Antlr4ParserRULE_keyword_select_uncompat = 422 - YQLv1Antlr4ParserRULE_keyword_alter_uncompat = 423 - YQLv1Antlr4ParserRULE_keyword_in_uncompat = 424 - YQLv1Antlr4ParserRULE_keyword_window_uncompat = 425 - YQLv1Antlr4ParserRULE_keyword_hint_uncompat = 426 - YQLv1Antlr4ParserRULE_keyword_as_compat = 427 - YQLv1Antlr4ParserRULE_keyword_compat = 428 - YQLv1Antlr4ParserRULE_type_id = 429 - YQLv1Antlr4ParserRULE_bool_value = 430 - YQLv1Antlr4ParserRULE_real = 431 - YQLv1Antlr4ParserRULE_integer = 432 + YQLParserRULE_sql_query = 0 + YQLParserRULE_sql_stmt_list = 1 + YQLParserRULE_ansi_sql_stmt_list = 2 + YQLParserRULE_lambda_body = 3 + YQLParserRULE_lambda_stmt = 4 + YQLParserRULE_sql_stmt = 5 + YQLParserRULE_sql_stmt_core = 6 + YQLParserRULE_expr = 7 + YQLParserRULE_or_subexpr = 8 + YQLParserRULE_and_subexpr = 9 + YQLParserRULE_xor_subexpr = 10 + YQLParserRULE_distinct_from_op = 11 + YQLParserRULE_cond_expr = 12 + YQLParserRULE_match_op = 13 + YQLParserRULE_eq_subexpr = 14 + YQLParserRULE_shift_right = 15 + YQLParserRULE_rot_right = 16 + YQLParserRULE_double_question = 17 + YQLParserRULE_neq_subexpr = 18 + YQLParserRULE_bit_subexpr = 19 + YQLParserRULE_add_subexpr = 20 + YQLParserRULE_mul_subexpr = 21 + YQLParserRULE_con_subexpr = 22 + YQLParserRULE_unary_op = 23 + YQLParserRULE_unary_subexpr_suffix = 24 + YQLParserRULE_unary_casual_subexpr = 25 + YQLParserRULE_in_unary_casual_subexpr = 26 + YQLParserRULE_unary_subexpr = 27 + YQLParserRULE_in_unary_subexpr = 28 + YQLParserRULE_list_literal = 29 + YQLParserRULE_expr_dict_list = 30 + YQLParserRULE_dict_literal = 31 + YQLParserRULE_expr_struct_list = 32 + YQLParserRULE_struct_literal = 33 + YQLParserRULE_atom_expr = 34 + YQLParserRULE_in_atom_expr = 35 + YQLParserRULE_cast_expr = 36 + YQLParserRULE_bitcast_expr = 37 + YQLParserRULE_exists_expr = 38 + YQLParserRULE_case_expr = 39 + YQLParserRULE_lambda = 40 + YQLParserRULE_in_expr = 41 + YQLParserRULE_json_api_expr = 42 + YQLParserRULE_jsonpath_spec = 43 + YQLParserRULE_json_variable_name = 44 + YQLParserRULE_json_variable = 45 + YQLParserRULE_json_variables = 46 + YQLParserRULE_json_common_args = 47 + YQLParserRULE_json_case_handler = 48 + YQLParserRULE_json_value = 49 + YQLParserRULE_json_exists_handler = 50 + YQLParserRULE_json_exists = 51 + YQLParserRULE_json_query_wrapper = 52 + YQLParserRULE_json_query_handler = 53 + YQLParserRULE_json_query = 54 + YQLParserRULE_smart_parenthesis = 55 + YQLParserRULE_expr_list = 56 + YQLParserRULE_pure_column_list = 57 + YQLParserRULE_pure_column_or_named = 58 + YQLParserRULE_pure_column_or_named_list = 59 + YQLParserRULE_column_name = 60 + YQLParserRULE_without_column_name = 61 + YQLParserRULE_column_list = 62 + YQLParserRULE_without_column_list = 63 + YQLParserRULE_named_expr = 64 + YQLParserRULE_named_expr_list = 65 + YQLParserRULE_invoke_expr = 66 + YQLParserRULE_invoke_expr_tail = 67 + YQLParserRULE_using_call_expr = 68 + YQLParserRULE_key_expr = 69 + YQLParserRULE_when_expr = 70 + YQLParserRULE_literal_value = 71 + YQLParserRULE_bind_parameter = 72 + YQLParserRULE_opt_bind_parameter = 73 + YQLParserRULE_bind_parameter_list = 74 + YQLParserRULE_named_bind_parameter = 75 + YQLParserRULE_named_bind_parameter_list = 76 + YQLParserRULE_signed_number = 77 + YQLParserRULE_type_name_simple = 78 + YQLParserRULE_integer_or_bind = 79 + YQLParserRULE_type_name_tag = 80 + YQLParserRULE_struct_arg = 81 + YQLParserRULE_struct_arg_positional = 82 + YQLParserRULE_variant_arg = 83 + YQLParserRULE_callable_arg = 84 + YQLParserRULE_callable_arg_list = 85 + YQLParserRULE_type_name_decimal = 86 + YQLParserRULE_type_name_optional = 87 + YQLParserRULE_type_name_tuple = 88 + YQLParserRULE_type_name_struct = 89 + YQLParserRULE_type_name_variant = 90 + YQLParserRULE_type_name_list = 91 + YQLParserRULE_type_name_stream = 92 + YQLParserRULE_type_name_flow = 93 + YQLParserRULE_type_name_dict = 94 + YQLParserRULE_type_name_set = 95 + YQLParserRULE_type_name_enum = 96 + YQLParserRULE_type_name_resource = 97 + YQLParserRULE_type_name_tagged = 98 + YQLParserRULE_type_name_callable = 99 + YQLParserRULE_type_name_composite = 100 + YQLParserRULE_type_name = 101 + YQLParserRULE_type_name_or_bind = 102 + YQLParserRULE_value_constructor_literal = 103 + YQLParserRULE_value_constructor = 104 + YQLParserRULE_declare_stmt = 105 + YQLParserRULE_module_path = 106 + YQLParserRULE_import_stmt = 107 + YQLParserRULE_export_stmt = 108 + YQLParserRULE_call_action = 109 + YQLParserRULE_inline_action = 110 + YQLParserRULE_do_stmt = 111 + YQLParserRULE_pragma_stmt = 112 + YQLParserRULE_pragma_value = 113 + YQLParserRULE_sort_specification = 114 + YQLParserRULE_sort_specification_list = 115 + YQLParserRULE_select_stmt = 116 + YQLParserRULE_select_unparenthesized_stmt = 117 + YQLParserRULE_select_kind_parenthesis = 118 + YQLParserRULE_select_op = 119 + YQLParserRULE_select_kind_partial = 120 + YQLParserRULE_select_kind = 121 + YQLParserRULE_process_core = 122 + YQLParserRULE_external_call_param = 123 + YQLParserRULE_external_call_settings = 124 + YQLParserRULE_reduce_core = 125 + YQLParserRULE_opt_set_quantifier = 126 + YQLParserRULE_select_core = 127 + YQLParserRULE_row_pattern_recognition_clause = 128 + YQLParserRULE_row_pattern_rows_per_match = 129 + YQLParserRULE_row_pattern_empty_match_handling = 130 + YQLParserRULE_row_pattern_measures = 131 + YQLParserRULE_row_pattern_measure_list = 132 + YQLParserRULE_row_pattern_measure_definition = 133 + YQLParserRULE_row_pattern_common_syntax = 134 + YQLParserRULE_row_pattern_skip_to = 135 + YQLParserRULE_row_pattern_skip_to_variable_name = 136 + YQLParserRULE_row_pattern_initial_or_seek = 137 + YQLParserRULE_row_pattern = 138 + YQLParserRULE_row_pattern_term = 139 + YQLParserRULE_row_pattern_factor = 140 + YQLParserRULE_row_pattern_quantifier = 141 + YQLParserRULE_row_pattern_primary = 142 + YQLParserRULE_row_pattern_primary_variable_name = 143 + YQLParserRULE_row_pattern_permute = 144 + YQLParserRULE_row_pattern_subset_clause = 145 + YQLParserRULE_row_pattern_subset_list = 146 + YQLParserRULE_row_pattern_subset_item = 147 + YQLParserRULE_row_pattern_subset_item_variable_name = 148 + YQLParserRULE_row_pattern_subset_rhs = 149 + YQLParserRULE_row_pattern_subset_rhs_variable_name = 150 + YQLParserRULE_row_pattern_definition_list = 151 + YQLParserRULE_row_pattern_definition = 152 + YQLParserRULE_row_pattern_definition_variable_name = 153 + YQLParserRULE_row_pattern_definition_search_condition = 154 + YQLParserRULE_search_condition = 155 + YQLParserRULE_row_pattern_variable_name = 156 + YQLParserRULE_order_by_clause = 157 + YQLParserRULE_ext_order_by_clause = 158 + YQLParserRULE_group_by_clause = 159 + YQLParserRULE_grouping_element_list = 160 + YQLParserRULE_grouping_element = 161 + YQLParserRULE_ordinary_grouping_set = 162 + YQLParserRULE_ordinary_grouping_set_list = 163 + YQLParserRULE_rollup_list = 164 + YQLParserRULE_cube_list = 165 + YQLParserRULE_grouping_sets_specification = 166 + YQLParserRULE_hopping_window_specification = 167 + YQLParserRULE_result_column = 168 + YQLParserRULE_join_source = 169 + YQLParserRULE_named_column = 170 + YQLParserRULE_flatten_by_arg = 171 + YQLParserRULE_flatten_source = 172 + YQLParserRULE_named_single_source = 173 + YQLParserRULE_single_source = 174 + YQLParserRULE_sample_clause = 175 + YQLParserRULE_tablesample_clause = 176 + YQLParserRULE_sampling_mode = 177 + YQLParserRULE_repeatable_clause = 178 + YQLParserRULE_join_op = 179 + YQLParserRULE_join_constraint = 180 + YQLParserRULE_returning_columns_list = 181 + YQLParserRULE_into_table_stmt = 182 + YQLParserRULE_into_values_source = 183 + YQLParserRULE_values_stmt = 184 + YQLParserRULE_values_source = 185 + YQLParserRULE_values_source_row_list = 186 + YQLParserRULE_values_source_row = 187 + YQLParserRULE_simple_values_source = 188 + YQLParserRULE_create_external_data_source_stmt = 189 + YQLParserRULE_alter_external_data_source_stmt = 190 + YQLParserRULE_alter_external_data_source_action = 191 + YQLParserRULE_drop_external_data_source_stmt = 192 + YQLParserRULE_create_view_stmt = 193 + YQLParserRULE_drop_view_stmt = 194 + YQLParserRULE_upsert_object_stmt = 195 + YQLParserRULE_create_object_stmt = 196 + YQLParserRULE_create_object_features = 197 + YQLParserRULE_alter_object_stmt = 198 + YQLParserRULE_alter_object_features = 199 + YQLParserRULE_drop_object_stmt = 200 + YQLParserRULE_drop_object_features = 201 + YQLParserRULE_object_feature_value = 202 + YQLParserRULE_object_feature_kv = 203 + YQLParserRULE_object_feature_flag = 204 + YQLParserRULE_object_feature = 205 + YQLParserRULE_object_features = 206 + YQLParserRULE_object_type_ref = 207 + YQLParserRULE_create_table_stmt = 208 + YQLParserRULE_create_table_entry = 209 + YQLParserRULE_create_backup_collection_stmt = 210 + YQLParserRULE_alter_backup_collection_stmt = 211 + YQLParserRULE_drop_backup_collection_stmt = 212 + YQLParserRULE_create_backup_collection_entries = 213 + YQLParserRULE_create_backup_collection_entries_many = 214 + YQLParserRULE_table_list = 215 + YQLParserRULE_alter_backup_collection_actions = 216 + YQLParserRULE_alter_backup_collection_action = 217 + YQLParserRULE_alter_backup_collection_entries = 218 + YQLParserRULE_alter_backup_collection_entry = 219 + YQLParserRULE_backup_collection = 220 + YQLParserRULE_backup_collection_settings = 221 + YQLParserRULE_backup_collection_settings_entry = 222 + YQLParserRULE_backup_stmt = 223 + YQLParserRULE_restore_stmt = 224 + YQLParserRULE_table_inherits = 225 + YQLParserRULE_table_partition_by = 226 + YQLParserRULE_with_table_settings = 227 + YQLParserRULE_table_tablestore = 228 + YQLParserRULE_table_settings_entry = 229 + YQLParserRULE_table_as_source = 230 + YQLParserRULE_alter_table_stmt = 231 + YQLParserRULE_alter_table_action = 232 + YQLParserRULE_alter_external_table_stmt = 233 + YQLParserRULE_alter_external_table_action = 234 + YQLParserRULE_alter_table_store_stmt = 235 + YQLParserRULE_alter_table_store_action = 236 + YQLParserRULE_alter_table_add_column = 237 + YQLParserRULE_alter_table_drop_column = 238 + YQLParserRULE_alter_table_alter_column = 239 + YQLParserRULE_alter_table_alter_column_drop_not_null = 240 + YQLParserRULE_alter_table_add_column_family = 241 + YQLParserRULE_alter_table_alter_column_family = 242 + YQLParserRULE_alter_table_set_table_setting_uncompat = 243 + YQLParserRULE_alter_table_set_table_setting_compat = 244 + YQLParserRULE_alter_table_reset_table_setting = 245 + YQLParserRULE_alter_table_add_index = 246 + YQLParserRULE_alter_table_drop_index = 247 + YQLParserRULE_alter_table_rename_to = 248 + YQLParserRULE_alter_table_rename_index_to = 249 + YQLParserRULE_alter_table_add_changefeed = 250 + YQLParserRULE_alter_table_alter_changefeed = 251 + YQLParserRULE_alter_table_drop_changefeed = 252 + YQLParserRULE_alter_table_alter_index = 253 + YQLParserRULE_column_schema = 254 + YQLParserRULE_family_relation = 255 + YQLParserRULE_opt_column_constraints = 256 + YQLParserRULE_column_order_by_specification = 257 + YQLParserRULE_table_constraint = 258 + YQLParserRULE_table_index = 259 + YQLParserRULE_table_index_type = 260 + YQLParserRULE_global_index = 261 + YQLParserRULE_local_index = 262 + YQLParserRULE_index_subtype = 263 + YQLParserRULE_with_index_settings = 264 + YQLParserRULE_index_setting_entry = 265 + YQLParserRULE_index_setting_value = 266 + YQLParserRULE_changefeed = 267 + YQLParserRULE_changefeed_settings = 268 + YQLParserRULE_changefeed_settings_entry = 269 + YQLParserRULE_changefeed_setting_value = 270 + YQLParserRULE_changefeed_alter_settings = 271 + YQLParserRULE_alter_table_setting_entry = 272 + YQLParserRULE_table_setting_value = 273 + YQLParserRULE_ttl_tier_list = 274 + YQLParserRULE_ttl_tier_action = 275 + YQLParserRULE_family_entry = 276 + YQLParserRULE_family_settings = 277 + YQLParserRULE_family_settings_entry = 278 + YQLParserRULE_family_setting_value = 279 + YQLParserRULE_split_boundaries = 280 + YQLParserRULE_literal_value_list = 281 + YQLParserRULE_alter_table_alter_index_action = 282 + YQLParserRULE_drop_table_stmt = 283 + YQLParserRULE_create_user_stmt = 284 + YQLParserRULE_alter_user_stmt = 285 + YQLParserRULE_create_group_stmt = 286 + YQLParserRULE_alter_group_stmt = 287 + YQLParserRULE_drop_role_stmt = 288 + YQLParserRULE_role_name = 289 + YQLParserRULE_create_user_option = 290 + YQLParserRULE_password_option = 291 + YQLParserRULE_login_option = 292 + YQLParserRULE_grant_permissions_stmt = 293 + YQLParserRULE_revoke_permissions_stmt = 294 + YQLParserRULE_permission_id = 295 + YQLParserRULE_permission_name = 296 + YQLParserRULE_permission_name_target = 297 + YQLParserRULE_create_resource_pool_stmt = 298 + YQLParserRULE_alter_resource_pool_stmt = 299 + YQLParserRULE_alter_resource_pool_action = 300 + YQLParserRULE_drop_resource_pool_stmt = 301 + YQLParserRULE_create_resource_pool_classifier_stmt = 302 + YQLParserRULE_alter_resource_pool_classifier_stmt = 303 + YQLParserRULE_alter_resource_pool_classifier_action = 304 + YQLParserRULE_drop_resource_pool_classifier_stmt = 305 + YQLParserRULE_create_replication_stmt = 306 + YQLParserRULE_replication_target = 307 + YQLParserRULE_replication_settings = 308 + YQLParserRULE_replication_settings_entry = 309 + YQLParserRULE_alter_replication_stmt = 310 + YQLParserRULE_alter_replication_action = 311 + YQLParserRULE_alter_replication_set_setting = 312 + YQLParserRULE_drop_replication_stmt = 313 + YQLParserRULE_action_or_subquery_args = 314 + YQLParserRULE_define_action_or_subquery_stmt = 315 + YQLParserRULE_define_action_or_subquery_body = 316 + YQLParserRULE_if_stmt = 317 + YQLParserRULE_for_stmt = 318 + YQLParserRULE_table_ref = 319 + YQLParserRULE_table_key = 320 + YQLParserRULE_table_arg = 321 + YQLParserRULE_table_hints = 322 + YQLParserRULE_table_hint = 323 + YQLParserRULE_object_ref = 324 + YQLParserRULE_simple_table_ref_core = 325 + YQLParserRULE_simple_table_ref = 326 + YQLParserRULE_into_simple_table_ref = 327 + YQLParserRULE_delete_stmt = 328 + YQLParserRULE_update_stmt = 329 + YQLParserRULE_set_clause_choice = 330 + YQLParserRULE_set_clause_list = 331 + YQLParserRULE_set_clause = 332 + YQLParserRULE_set_target = 333 + YQLParserRULE_multiple_column_assignment = 334 + YQLParserRULE_set_target_list = 335 + YQLParserRULE_create_topic_stmt = 336 + YQLParserRULE_create_topic_entries = 337 + YQLParserRULE_create_topic_entry = 338 + YQLParserRULE_with_topic_settings = 339 + YQLParserRULE_alter_topic_stmt = 340 + YQLParserRULE_alter_topic_action = 341 + YQLParserRULE_alter_topic_add_consumer = 342 + YQLParserRULE_topic_create_consumer_entry = 343 + YQLParserRULE_alter_topic_alter_consumer = 344 + YQLParserRULE_alter_topic_alter_consumer_entry = 345 + YQLParserRULE_alter_topic_drop_consumer = 346 + YQLParserRULE_topic_alter_consumer_set = 347 + YQLParserRULE_topic_alter_consumer_reset = 348 + YQLParserRULE_alter_topic_set_settings = 349 + YQLParserRULE_alter_topic_reset_settings = 350 + YQLParserRULE_drop_topic_stmt = 351 + YQLParserRULE_topic_settings = 352 + YQLParserRULE_topic_settings_entry = 353 + YQLParserRULE_topic_setting_value = 354 + YQLParserRULE_topic_consumer_with_settings = 355 + YQLParserRULE_topic_consumer_settings = 356 + YQLParserRULE_topic_consumer_settings_entry = 357 + YQLParserRULE_topic_consumer_setting_value = 358 + YQLParserRULE_topic_ref = 359 + YQLParserRULE_topic_consumer_ref = 360 + YQLParserRULE_null_treatment = 361 + YQLParserRULE_filter_clause = 362 + YQLParserRULE_window_name_or_specification = 363 + YQLParserRULE_window_name = 364 + YQLParserRULE_window_clause = 365 + YQLParserRULE_window_definition_list = 366 + YQLParserRULE_window_definition = 367 + YQLParserRULE_new_window_name = 368 + YQLParserRULE_window_specification = 369 + YQLParserRULE_window_specification_details = 370 + YQLParserRULE_existing_window_name = 371 + YQLParserRULE_window_partition_clause = 372 + YQLParserRULE_window_order_clause = 373 + YQLParserRULE_window_frame_clause = 374 + YQLParserRULE_window_frame_units = 375 + YQLParserRULE_window_frame_extent = 376 + YQLParserRULE_window_frame_between = 377 + YQLParserRULE_window_frame_bound = 378 + YQLParserRULE_window_frame_exclusion = 379 + YQLParserRULE_use_stmt = 380 + YQLParserRULE_subselect_stmt = 381 + YQLParserRULE_named_nodes_stmt = 382 + YQLParserRULE_commit_stmt = 383 + YQLParserRULE_rollback_stmt = 384 + YQLParserRULE_analyze_table = 385 + YQLParserRULE_analyze_table_list = 386 + YQLParserRULE_analyze_stmt = 387 + YQLParserRULE_alter_sequence_stmt = 388 + YQLParserRULE_alter_sequence_action = 389 + YQLParserRULE_identifier = 390 + YQLParserRULE_id = 391 + YQLParserRULE_id_schema = 392 + YQLParserRULE_id_expr = 393 + YQLParserRULE_id_expr_in = 394 + YQLParserRULE_id_window = 395 + YQLParserRULE_id_table = 396 + YQLParserRULE_id_without = 397 + YQLParserRULE_id_hint = 398 + YQLParserRULE_id_as_compat = 399 + YQLParserRULE_an_id = 400 + YQLParserRULE_an_id_or_type = 401 + YQLParserRULE_an_id_schema = 402 + YQLParserRULE_an_id_expr = 403 + YQLParserRULE_an_id_expr_in = 404 + YQLParserRULE_an_id_window = 405 + YQLParserRULE_an_id_table = 406 + YQLParserRULE_an_id_without = 407 + YQLParserRULE_an_id_hint = 408 + YQLParserRULE_an_id_pure = 409 + YQLParserRULE_an_id_as_compat = 410 + YQLParserRULE_view_name = 411 + YQLParserRULE_opt_id_prefix = 412 + YQLParserRULE_cluster_expr = 413 + YQLParserRULE_id_or_type = 414 + YQLParserRULE_opt_id_prefix_or_type = 415 + YQLParserRULE_id_or_at = 416 + YQLParserRULE_id_table_or_type = 417 + YQLParserRULE_id_table_or_at = 418 + YQLParserRULE_keyword = 419 + YQLParserRULE_keyword_expr_uncompat = 420 + YQLParserRULE_keyword_table_uncompat = 421 + YQLParserRULE_keyword_select_uncompat = 422 + YQLParserRULE_keyword_alter_uncompat = 423 + YQLParserRULE_keyword_in_uncompat = 424 + YQLParserRULE_keyword_window_uncompat = 425 + YQLParserRULE_keyword_hint_uncompat = 426 + YQLParserRULE_keyword_as_compat = 427 + YQLParserRULE_keyword_compat = 428 + YQLParserRULE_type_id = 429 + YQLParserRULE_bool_value = 430 + YQLParserRULE_real = 431 + YQLParserRULE_integer = 432 ) // ISql_queryContext is an interface to support dynamic dispatch. @@ -3353,13 +3353,13 @@ type Sql_queryContext struct { func NewEmptySql_queryContext() *Sql_queryContext { var p = new(Sql_queryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_query + p.RuleIndex = YQLParserRULE_sql_query return p } func InitEmptySql_queryContext(p *Sql_queryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_query + p.RuleIndex = YQLParserRULE_sql_query } func (*Sql_queryContext) IsSql_queryContext() {} @@ -3370,7 +3370,7 @@ func NewSql_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_query + p.RuleIndex = YQLParserRULE_sql_query return p } @@ -3394,15 +3394,15 @@ func (s *Sql_queryContext) Sql_stmt_list() ISql_stmt_listContext { } func (s *Sql_queryContext) PRAGMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRAGMA, 0) + return s.GetToken(YQLParserPRAGMA, 0) } func (s *Sql_queryContext) ANSI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANSI, 0) + return s.GetToken(YQLParserANSI, 0) } func (s *Sql_queryContext) DIGITS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDIGITS, 0) + return s.GetToken(YQLParserDIGITS, 0) } func (s *Sql_queryContext) Ansi_sql_stmt_list() IAnsi_sql_stmt_listContext { @@ -3431,13 +3431,13 @@ func (s *Sql_queryContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Sql_queryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSql_query(s) } } func (s *Sql_queryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSql_query(s) } } @@ -3445,9 +3445,9 @@ func (s *Sql_queryContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Sql_query() (localctx ISql_queryContext) { +func (p *YQLParser) Sql_query() (localctx ISql_queryContext) { localctx = NewSql_queryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 0, YQLv1Antlr4ParserRULE_sql_query) + p.EnterRule(localctx, 0, YQLParserRULE_sql_query) p.SetState(871) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -3467,7 +3467,7 @@ func (p *YQLv1Antlr4Parser) Sql_query() (localctx ISql_queryContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(867) - p.Match(YQLv1Antlr4ParserPRAGMA) + p.Match(YQLParserPRAGMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3475,7 +3475,7 @@ func (p *YQLv1Antlr4Parser) Sql_query() (localctx ISql_queryContext) { } { p.SetState(868) - p.Match(YQLv1Antlr4ParserANSI) + p.Match(YQLParserANSI) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3483,7 +3483,7 @@ func (p *YQLv1Antlr4Parser) Sql_query() (localctx ISql_queryContext) { } { p.SetState(869) - p.Match(YQLv1Antlr4ParserDIGITS) + p.Match(YQLParserDIGITS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3539,13 +3539,13 @@ type Sql_stmt_listContext struct { func NewEmptySql_stmt_listContext() *Sql_stmt_listContext { var p = new(Sql_stmt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt_list + p.RuleIndex = YQLParserRULE_sql_stmt_list return p } func InitEmptySql_stmt_listContext(p *Sql_stmt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt_list + p.RuleIndex = YQLParserRULE_sql_stmt_list } func (*Sql_stmt_listContext) IsSql_stmt_listContext() {} @@ -3556,7 +3556,7 @@ func NewSql_stmt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt_list + p.RuleIndex = YQLParserRULE_sql_stmt_list return p } @@ -3605,15 +3605,15 @@ func (s *Sql_stmt_listContext) Sql_stmt(i int) ISql_stmtContext { } func (s *Sql_stmt_listContext) EOF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEOF, 0) + return s.GetToken(YQLParserEOF, 0) } func (s *Sql_stmt_listContext) AllSEMICOLON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserSEMICOLON) + return s.GetTokens(YQLParserSEMICOLON) } func (s *Sql_stmt_listContext) SEMICOLON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEMICOLON, i) + return s.GetToken(YQLParserSEMICOLON, i) } func (s *Sql_stmt_listContext) GetRuleContext() antlr.RuleContext { @@ -3626,13 +3626,13 @@ func (s *Sql_stmt_listContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Sql_stmt_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSql_stmt_list(s) } } func (s *Sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSql_stmt_list(s) } } @@ -3640,9 +3640,9 @@ func (s *Sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Sql_stmt_list() (localctx ISql_stmt_listContext) { +func (p *YQLParser) Sql_stmt_list() (localctx ISql_stmt_listContext) { localctx = NewSql_stmt_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 2, YQLv1Antlr4ParserRULE_sql_stmt_list) + p.EnterRule(localctx, 2, YQLParserRULE_sql_stmt_list) var _la int var _alt int @@ -3656,10 +3656,10 @@ func (p *YQLv1Antlr4Parser) Sql_stmt_list() (localctx ISql_stmt_listContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserSEMICOLON { + for _la == YQLParserSEMICOLON { { p.SetState(873) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3697,10 +3697,10 @@ func (p *YQLv1Antlr4Parser) Sql_stmt_list() (localctx ISql_stmt_listContext) { _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == YQLv1Antlr4ParserSEMICOLON { + for ok := true; ok; ok = _la == YQLParserSEMICOLON { { p.SetState(880) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3740,10 +3740,10 @@ func (p *YQLv1Antlr4Parser) Sql_stmt_list() (localctx ISql_stmt_listContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserSEMICOLON { + for _la == YQLParserSEMICOLON { { p.SetState(891) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3760,7 +3760,7 @@ func (p *YQLv1Antlr4Parser) Sql_stmt_list() (localctx ISql_stmt_listContext) { } { p.SetState(897) - p.Match(YQLv1Antlr4ParserEOF) + p.Match(YQLParserEOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3807,13 +3807,13 @@ type Ansi_sql_stmt_listContext struct { func NewEmptyAnsi_sql_stmt_listContext() *Ansi_sql_stmt_listContext { var p = new(Ansi_sql_stmt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ansi_sql_stmt_list + p.RuleIndex = YQLParserRULE_ansi_sql_stmt_list return p } func InitEmptyAnsi_sql_stmt_listContext(p *Ansi_sql_stmt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ansi_sql_stmt_list + p.RuleIndex = YQLParserRULE_ansi_sql_stmt_list } func (*Ansi_sql_stmt_listContext) IsAnsi_sql_stmt_listContext() {} @@ -3824,7 +3824,7 @@ func NewAnsi_sql_stmt_listContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_ansi_sql_stmt_list + p.RuleIndex = YQLParserRULE_ansi_sql_stmt_list return p } @@ -3832,15 +3832,15 @@ func NewAnsi_sql_stmt_listContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Ansi_sql_stmt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Ansi_sql_stmt_listContext) EOF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEOF, 0) + return s.GetToken(YQLParserEOF, 0) } func (s *Ansi_sql_stmt_listContext) AllSEMICOLON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserSEMICOLON) + return s.GetTokens(YQLParserSEMICOLON) } func (s *Ansi_sql_stmt_listContext) SEMICOLON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEMICOLON, i) + return s.GetToken(YQLParserSEMICOLON, i) } func (s *Ansi_sql_stmt_listContext) GetRuleContext() antlr.RuleContext { @@ -3853,13 +3853,13 @@ func (s *Ansi_sql_stmt_listContext) ToStringTree(ruleNames []string, recog antlr func (s *Ansi_sql_stmt_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAnsi_sql_stmt_list(s) } } func (s *Ansi_sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAnsi_sql_stmt_list(s) } } @@ -3867,9 +3867,9 @@ func (s *Ansi_sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Ansi_sql_stmt_list() (localctx IAnsi_sql_stmt_listContext) { +func (p *YQLParser) Ansi_sql_stmt_list() (localctx IAnsi_sql_stmt_listContext) { localctx = NewAnsi_sql_stmt_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 4, YQLv1Antlr4ParserRULE_ansi_sql_stmt_list) + p.EnterRule(localctx, 4, YQLParserRULE_ansi_sql_stmt_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -3881,10 +3881,10 @@ func (p *YQLv1Antlr4Parser) Ansi_sql_stmt_list() (localctx IAnsi_sql_stmt_listCo _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserSEMICOLON { + for _la == YQLParserSEMICOLON { { p.SetState(899) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3901,7 +3901,7 @@ func (p *YQLv1Antlr4Parser) Ansi_sql_stmt_list() (localctx IAnsi_sql_stmt_listCo } { p.SetState(905) - p.Match(YQLv1Antlr4ParserEOF) + p.Match(YQLParserEOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -3951,13 +3951,13 @@ type Lambda_bodyContext struct { func NewEmptyLambda_bodyContext() *Lambda_bodyContext { var p = new(Lambda_bodyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda_body + p.RuleIndex = YQLParserRULE_lambda_body return p } func InitEmptyLambda_bodyContext(p *Lambda_bodyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda_body + p.RuleIndex = YQLParserRULE_lambda_body } func (*Lambda_bodyContext) IsLambda_bodyContext() {} @@ -3968,7 +3968,7 @@ func NewLambda_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda_body + p.RuleIndex = YQLParserRULE_lambda_body return p } @@ -3976,7 +3976,7 @@ func NewLambda_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Lambda_bodyContext) GetParser() antlr.Parser { return s.parser } func (s *Lambda_bodyContext) RETURN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRETURN, 0) + return s.GetToken(YQLParserRETURN, 0) } func (s *Lambda_bodyContext) Expr() IExprContext { @@ -3996,11 +3996,11 @@ func (s *Lambda_bodyContext) Expr() IExprContext { } func (s *Lambda_bodyContext) AllSEMICOLON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserSEMICOLON) + return s.GetTokens(YQLParserSEMICOLON) } func (s *Lambda_bodyContext) SEMICOLON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEMICOLON, i) + return s.GetToken(YQLParserSEMICOLON, i) } func (s *Lambda_bodyContext) AllLambda_stmt() []ILambda_stmtContext { @@ -4054,13 +4054,13 @@ func (s *Lambda_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Lambda_bodyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterLambda_body(s) } } func (s *Lambda_bodyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitLambda_body(s) } } @@ -4068,9 +4068,9 @@ func (s *Lambda_bodyContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Lambda_body() (localctx ILambda_bodyContext) { +func (p *YQLParser) Lambda_body() (localctx ILambda_bodyContext) { localctx = NewLambda_bodyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 6, YQLv1Antlr4ParserRULE_lambda_body) + p.EnterRule(localctx, 6, YQLParserRULE_lambda_body) var _la int p.EnterOuterAlt(localctx, 1) @@ -4082,10 +4082,10 @@ func (p *YQLv1Antlr4Parser) Lambda_body() (localctx ILambda_bodyContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserSEMICOLON { + for _la == YQLParserSEMICOLON { { p.SetState(907) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4108,7 +4108,7 @@ func (p *YQLv1Antlr4Parser) Lambda_body() (localctx ILambda_bodyContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserDOLLAR || _la == YQLv1Antlr4ParserIMPORT { + for _la == YQLParserDOLLAR || _la == YQLParserIMPORT { { p.SetState(913) p.Lambda_stmt() @@ -4121,10 +4121,10 @@ func (p *YQLv1Antlr4Parser) Lambda_body() (localctx ILambda_bodyContext) { _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == YQLv1Antlr4ParserSEMICOLON { + for ok := true; ok; ok = _la == YQLParserSEMICOLON { { p.SetState(914) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4150,7 +4150,7 @@ func (p *YQLv1Antlr4Parser) Lambda_body() (localctx ILambda_bodyContext) { } { p.SetState(924) - p.Match(YQLv1Antlr4ParserRETURN) + p.Match(YQLParserRETURN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4168,10 +4168,10 @@ func (p *YQLv1Antlr4Parser) Lambda_body() (localctx ILambda_bodyContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserSEMICOLON { + for _la == YQLParserSEMICOLON { { p.SetState(926) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4226,13 +4226,13 @@ type Lambda_stmtContext struct { func NewEmptyLambda_stmtContext() *Lambda_stmtContext { var p = new(Lambda_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda_stmt + p.RuleIndex = YQLParserRULE_lambda_stmt return p } func InitEmptyLambda_stmtContext(p *Lambda_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda_stmt + p.RuleIndex = YQLParserRULE_lambda_stmt } func (*Lambda_stmtContext) IsLambda_stmtContext() {} @@ -4243,7 +4243,7 @@ func NewLambda_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda_stmt + p.RuleIndex = YQLParserRULE_lambda_stmt return p } @@ -4292,13 +4292,13 @@ func (s *Lambda_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Lambda_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterLambda_stmt(s) } } func (s *Lambda_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitLambda_stmt(s) } } @@ -4306,9 +4306,9 @@ func (s *Lambda_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Lambda_stmt() (localctx ILambda_stmtContext) { +func (p *YQLParser) Lambda_stmt() (localctx ILambda_stmtContext) { localctx = NewLambda_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 8, YQLv1Antlr4ParserRULE_lambda_stmt) + p.EnterRule(localctx, 8, YQLParserRULE_lambda_stmt) p.SetState(934) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -4316,7 +4316,7 @@ func (p *YQLv1Antlr4Parser) Lambda_stmt() (localctx ILambda_stmtContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 1) { p.SetState(932) @@ -4324,7 +4324,7 @@ func (p *YQLv1Antlr4Parser) Lambda_stmt() (localctx ILambda_stmtContext) { } - case YQLv1Antlr4ParserIMPORT: + case YQLParserIMPORT: p.EnterOuterAlt(localctx, 2) { p.SetState(933) @@ -4378,13 +4378,13 @@ type Sql_stmtContext struct { func NewEmptySql_stmtContext() *Sql_stmtContext { var p = new(Sql_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt + p.RuleIndex = YQLParserRULE_sql_stmt return p } func InitEmptySql_stmtContext(p *Sql_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt + p.RuleIndex = YQLParserRULE_sql_stmt } func (*Sql_stmtContext) IsSql_stmtContext() {} @@ -4395,7 +4395,7 @@ func NewSql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt + p.RuleIndex = YQLParserRULE_sql_stmt return p } @@ -4419,15 +4419,15 @@ func (s *Sql_stmtContext) Sql_stmt_core() ISql_stmt_coreContext { } func (s *Sql_stmtContext) EXPLAIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXPLAIN, 0) + return s.GetToken(YQLParserEXPLAIN, 0) } func (s *Sql_stmtContext) QUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUERY, 0) + return s.GetToken(YQLParserQUERY, 0) } func (s *Sql_stmtContext) PLAN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPLAN, 0) + return s.GetToken(YQLParserPLAN, 0) } func (s *Sql_stmtContext) GetRuleContext() antlr.RuleContext { @@ -4440,13 +4440,13 @@ func (s *Sql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *Sql_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSql_stmt(s) } } func (s *Sql_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSql_stmt(s) } } @@ -4454,9 +4454,9 @@ func (s *Sql_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Sql_stmt() (localctx ISql_stmtContext) { +func (p *YQLParser) Sql_stmt() (localctx ISql_stmtContext) { localctx = NewSql_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 10, YQLv1Antlr4ParserRULE_sql_stmt) + p.EnterRule(localctx, 10, YQLParserRULE_sql_stmt) var _la int p.EnterOuterAlt(localctx, 1) @@ -4468,10 +4468,10 @@ func (p *YQLv1Antlr4Parser) Sql_stmt() (localctx ISql_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEXPLAIN { + if _la == YQLParserEXPLAIN { { p.SetState(936) - p.Match(YQLv1Antlr4ParserEXPLAIN) + p.Match(YQLParserEXPLAIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4485,10 +4485,10 @@ func (p *YQLv1Antlr4Parser) Sql_stmt() (localctx ISql_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserQUERY { + if _la == YQLParserQUERY { { p.SetState(937) - p.Match(YQLv1Antlr4ParserQUERY) + p.Match(YQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4496,7 +4496,7 @@ func (p *YQLv1Antlr4Parser) Sql_stmt() (localctx ISql_stmtContext) { } { p.SetState(938) - p.Match(YQLv1Antlr4ParserPLAN) + p.Match(YQLParserPLAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4605,13 +4605,13 @@ type Sql_stmt_coreContext struct { func NewEmptySql_stmt_coreContext() *Sql_stmt_coreContext { var p = new(Sql_stmt_coreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt_core + p.RuleIndex = YQLParserRULE_sql_stmt_core return p } func InitEmptySql_stmt_coreContext(p *Sql_stmt_coreContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt_core + p.RuleIndex = YQLParserRULE_sql_stmt_core } func (*Sql_stmt_coreContext) IsSql_stmt_coreContext() {} @@ -4622,7 +4622,7 @@ func NewSql_stmt_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sql_stmt_core + p.RuleIndex = YQLParserRULE_sql_stmt_core return p } @@ -5551,13 +5551,13 @@ func (s *Sql_stmt_coreContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Sql_stmt_coreContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSql_stmt_core(s) } } func (s *Sql_stmt_coreContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSql_stmt_core(s) } } @@ -5565,9 +5565,9 @@ func (s *Sql_stmt_coreContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Sql_stmt_core() (localctx ISql_stmt_coreContext) { +func (p *YQLParser) Sql_stmt_core() (localctx ISql_stmt_coreContext) { localctx = NewSql_stmt_coreContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 12, YQLv1Antlr4ParserRULE_sql_stmt_core) + p.EnterRule(localctx, 12, YQLParserRULE_sql_stmt_core) p.SetState(1002) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -6075,13 +6075,13 @@ type ExprContext struct { func NewEmptyExprContext() *ExprContext { var p = new(ExprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr + p.RuleIndex = YQLParserRULE_expr return p } func InitEmptyExprContext(p *ExprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr + p.RuleIndex = YQLParserRULE_expr } func (*ExprContext) IsExprContext() {} @@ -6092,7 +6092,7 @@ func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokin antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_expr + p.RuleIndex = YQLParserRULE_expr return p } @@ -6141,11 +6141,11 @@ func (s *ExprContext) Or_subexpr(i int) IOr_subexprContext { } func (s *ExprContext) AllOR() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserOR) + return s.GetTokens(YQLParserOR) } func (s *ExprContext) OR(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOR, i) + return s.GetToken(YQLParserOR, i) } func (s *ExprContext) Type_name_composite() IType_name_compositeContext { @@ -6174,13 +6174,13 @@ func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) s func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExpr(s) } } func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExpr(s) } } @@ -6188,9 +6188,9 @@ func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Expr() (localctx IExprContext) { +func (p *YQLParser) Expr() (localctx IExprContext) { localctx = NewExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 14, YQLv1Antlr4ParserRULE_expr) + p.EnterRule(localctx, 14, YQLParserRULE_expr) var _alt int p.SetState(1013) @@ -6219,7 +6219,7 @@ func (p *YQLv1Antlr4Parser) Expr() (localctx IExprContext) { if _alt == 1 { { p.SetState(1005) - p.Match(YQLv1Antlr4ParserOR) + p.Match(YQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6295,13 +6295,13 @@ type Or_subexprContext struct { func NewEmptyOr_subexprContext() *Or_subexprContext { var p = new(Or_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_or_subexpr + p.RuleIndex = YQLParserRULE_or_subexpr return p } func InitEmptyOr_subexprContext(p *Or_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_or_subexpr + p.RuleIndex = YQLParserRULE_or_subexpr } func (*Or_subexprContext) IsOr_subexprContext() {} @@ -6312,7 +6312,7 @@ func NewOr_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_or_subexpr + p.RuleIndex = YQLParserRULE_or_subexpr return p } @@ -6361,11 +6361,11 @@ func (s *Or_subexprContext) And_subexpr(i int) IAnd_subexprContext { } func (s *Or_subexprContext) AllAND() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserAND) + return s.GetTokens(YQLParserAND) } func (s *Or_subexprContext) AND(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAND, i) + return s.GetToken(YQLParserAND, i) } func (s *Or_subexprContext) GetRuleContext() antlr.RuleContext { @@ -6378,13 +6378,13 @@ func (s *Or_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Or_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOr_subexpr(s) } } func (s *Or_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOr_subexpr(s) } } @@ -6392,9 +6392,9 @@ func (s *Or_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Or_subexpr() (localctx IOr_subexprContext) { +func (p *YQLParser) Or_subexpr() (localctx IOr_subexprContext) { localctx = NewOr_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 16, YQLv1Antlr4ParserRULE_or_subexpr) + p.EnterRule(localctx, 16, YQLParserRULE_or_subexpr) var _alt int p.EnterOuterAlt(localctx, 1) @@ -6415,7 +6415,7 @@ func (p *YQLv1Antlr4Parser) Or_subexpr() (localctx IOr_subexprContext) { if _alt == 1 { { p.SetState(1016) - p.Match(YQLv1Antlr4ParserAND) + p.Match(YQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6480,13 +6480,13 @@ type And_subexprContext struct { func NewEmptyAnd_subexprContext() *And_subexprContext { var p = new(And_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_and_subexpr + p.RuleIndex = YQLParserRULE_and_subexpr return p } func InitEmptyAnd_subexprContext(p *And_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_and_subexpr + p.RuleIndex = YQLParserRULE_and_subexpr } func (*And_subexprContext) IsAnd_subexprContext() {} @@ -6497,7 +6497,7 @@ func NewAnd_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_and_subexpr + p.RuleIndex = YQLParserRULE_and_subexpr return p } @@ -6546,11 +6546,11 @@ func (s *And_subexprContext) Xor_subexpr(i int) IXor_subexprContext { } func (s *And_subexprContext) AllXOR() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserXOR) + return s.GetTokens(YQLParserXOR) } func (s *And_subexprContext) XOR(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserXOR, i) + return s.GetToken(YQLParserXOR, i) } func (s *And_subexprContext) GetRuleContext() antlr.RuleContext { @@ -6563,13 +6563,13 @@ func (s *And_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *And_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAnd_subexpr(s) } } func (s *And_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAnd_subexpr(s) } } @@ -6577,9 +6577,9 @@ func (s *And_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) And_subexpr() (localctx IAnd_subexprContext) { +func (p *YQLParser) And_subexpr() (localctx IAnd_subexprContext) { localctx = NewAnd_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 18, YQLv1Antlr4ParserRULE_and_subexpr) + p.EnterRule(localctx, 18, YQLParserRULE_and_subexpr) var _alt int p.EnterOuterAlt(localctx, 1) @@ -6600,7 +6600,7 @@ func (p *YQLv1Antlr4Parser) And_subexpr() (localctx IAnd_subexprContext) { if _alt == 1 { { p.SetState(1024) - p.Match(YQLv1Antlr4ParserXOR) + p.Match(YQLParserXOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6663,13 +6663,13 @@ type Xor_subexprContext struct { func NewEmptyXor_subexprContext() *Xor_subexprContext { var p = new(Xor_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_xor_subexpr + p.RuleIndex = YQLParserRULE_xor_subexpr return p } func InitEmptyXor_subexprContext(p *Xor_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_xor_subexpr + p.RuleIndex = YQLParserRULE_xor_subexpr } func (*Xor_subexprContext) IsXor_subexprContext() {} @@ -6680,7 +6680,7 @@ func NewXor_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_xor_subexpr + p.RuleIndex = YQLParserRULE_xor_subexpr return p } @@ -6729,13 +6729,13 @@ func (s *Xor_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Xor_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterXor_subexpr(s) } } func (s *Xor_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitXor_subexpr(s) } } @@ -6743,9 +6743,9 @@ func (s *Xor_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Xor_subexpr() (localctx IXor_subexprContext) { +func (p *YQLParser) Xor_subexpr() (localctx IXor_subexprContext) { localctx = NewXor_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 20, YQLv1Antlr4ParserRULE_xor_subexpr) + p.EnterRule(localctx, 20, YQLParserRULE_xor_subexpr) p.EnterOuterAlt(localctx, 1) { p.SetState(1031) @@ -6806,13 +6806,13 @@ type Distinct_from_opContext struct { func NewEmptyDistinct_from_opContext() *Distinct_from_opContext { var p = new(Distinct_from_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_distinct_from_op + p.RuleIndex = YQLParserRULE_distinct_from_op return p } func InitEmptyDistinct_from_opContext(p *Distinct_from_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_distinct_from_op + p.RuleIndex = YQLParserRULE_distinct_from_op } func (*Distinct_from_opContext) IsDistinct_from_opContext() {} @@ -6823,7 +6823,7 @@ func NewDistinct_from_opContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_distinct_from_op + p.RuleIndex = YQLParserRULE_distinct_from_op return p } @@ -6831,19 +6831,19 @@ func NewDistinct_from_opContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Distinct_from_opContext) GetParser() antlr.Parser { return s.parser } func (s *Distinct_from_opContext) IS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIS, 0) + return s.GetToken(YQLParserIS, 0) } func (s *Distinct_from_opContext) DISTINCT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISTINCT, 0) + return s.GetToken(YQLParserDISTINCT, 0) } func (s *Distinct_from_opContext) FROM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFROM, 0) + return s.GetToken(YQLParserFROM, 0) } func (s *Distinct_from_opContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Distinct_from_opContext) GetRuleContext() antlr.RuleContext { @@ -6856,13 +6856,13 @@ func (s *Distinct_from_opContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Distinct_from_opContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDistinct_from_op(s) } } func (s *Distinct_from_opContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDistinct_from_op(s) } } @@ -6870,15 +6870,15 @@ func (s *Distinct_from_opContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Distinct_from_op() (localctx IDistinct_from_opContext) { +func (p *YQLParser) Distinct_from_op() (localctx IDistinct_from_opContext) { localctx = NewDistinct_from_opContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 22, YQLv1Antlr4ParserRULE_distinct_from_op) + p.EnterRule(localctx, 22, YQLParserRULE_distinct_from_op) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1035) - p.Match(YQLv1Antlr4ParserIS) + p.Match(YQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6892,10 +6892,10 @@ func (p *YQLv1Antlr4Parser) Distinct_from_op() (localctx IDistinct_from_opContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT { + if _la == YQLParserNOT { { p.SetState(1036) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6905,7 +6905,7 @@ func (p *YQLv1Antlr4Parser) Distinct_from_op() (localctx IDistinct_from_opContex } { p.SetState(1039) - p.Match(YQLv1Antlr4ParserDISTINCT) + p.Match(YQLParserDISTINCT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6913,7 +6913,7 @@ func (p *YQLv1Antlr4Parser) Distinct_from_op() (localctx IDistinct_from_opContex } { p.SetState(1040) - p.Match(YQLv1Antlr4ParserFROM) + p.Match(YQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6983,13 +6983,13 @@ type Cond_exprContext struct { func NewEmptyCond_exprContext() *Cond_exprContext { var p = new(Cond_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cond_expr + p.RuleIndex = YQLParserRULE_cond_expr return p } func InitEmptyCond_exprContext(p *Cond_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cond_expr + p.RuleIndex = YQLParserRULE_cond_expr } func (*Cond_exprContext) IsCond_exprContext() {} @@ -7000,7 +7000,7 @@ func NewCond_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_cond_expr + p.RuleIndex = YQLParserRULE_cond_expr return p } @@ -7065,15 +7065,15 @@ func (s *Cond_exprContext) Eq_subexpr(i int) IEq_subexprContext { } func (s *Cond_exprContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Cond_exprContext) ESCAPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserESCAPE, 0) + return s.GetToken(YQLParserESCAPE, 0) } func (s *Cond_exprContext) IN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIN, 0) + return s.GetToken(YQLParserIN, 0) } func (s *Cond_exprContext) In_expr() IIn_exprContext { @@ -7093,71 +7093,71 @@ func (s *Cond_exprContext) In_expr() IIn_exprContext { } func (s *Cond_exprContext) COMPACT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMPACT, 0) + return s.GetToken(YQLParserCOMPACT, 0) } func (s *Cond_exprContext) ISNULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserISNULL, 0) + return s.GetToken(YQLParserISNULL, 0) } func (s *Cond_exprContext) NOTNULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOTNULL, 0) + return s.GetToken(YQLParserNOTNULL, 0) } func (s *Cond_exprContext) IS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIS, 0) + return s.GetToken(YQLParserIS, 0) } func (s *Cond_exprContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Cond_exprContext) BETWEEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBETWEEN, 0) + return s.GetToken(YQLParserBETWEEN, 0) } func (s *Cond_exprContext) AND() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAND, 0) + return s.GetToken(YQLParserAND, 0) } func (s *Cond_exprContext) SYMMETRIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYMMETRIC, 0) + return s.GetToken(YQLParserSYMMETRIC, 0) } func (s *Cond_exprContext) ASYMMETRIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYMMETRIC, 0) + return s.GetToken(YQLParserASYMMETRIC, 0) } func (s *Cond_exprContext) AllEQUALS() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserEQUALS) + return s.GetTokens(YQLParserEQUALS) } func (s *Cond_exprContext) EQUALS(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, i) + return s.GetToken(YQLParserEQUALS, i) } func (s *Cond_exprContext) AllEQUALS2() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserEQUALS2) + return s.GetTokens(YQLParserEQUALS2) } func (s *Cond_exprContext) EQUALS2(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS2, i) + return s.GetToken(YQLParserEQUALS2, i) } func (s *Cond_exprContext) AllNOT_EQUALS() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserNOT_EQUALS) + return s.GetTokens(YQLParserNOT_EQUALS) } func (s *Cond_exprContext) NOT_EQUALS(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT_EQUALS, i) + return s.GetToken(YQLParserNOT_EQUALS, i) } func (s *Cond_exprContext) AllNOT_EQUALS2() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserNOT_EQUALS2) + return s.GetTokens(YQLParserNOT_EQUALS2) } func (s *Cond_exprContext) NOT_EQUALS2(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT_EQUALS2, i) + return s.GetToken(YQLParserNOT_EQUALS2, i) } func (s *Cond_exprContext) AllDistinct_from_op() []IDistinct_from_opContext { @@ -7211,13 +7211,13 @@ func (s *Cond_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Cond_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCond_expr(s) } } func (s *Cond_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCond_expr(s) } } @@ -7225,9 +7225,9 @@ func (s *Cond_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { +func (p *YQLParser) Cond_expr() (localctx ICond_exprContext) { localctx = NewCond_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 24, YQLv1Antlr4ParserRULE_cond_expr) + p.EnterRule(localctx, 24, YQLParserRULE_cond_expr) var _la int var _alt int @@ -7249,10 +7249,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT { + if _la == YQLParserNOT { { p.SetState(1042) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7275,7 +7275,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) == 1 { { p.SetState(1047) - p.Match(YQLv1Antlr4ParserESCAPE) + p.Match(YQLParserESCAPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7301,10 +7301,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT { + if _la == YQLParserNOT { { p.SetState(1051) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7314,7 +7314,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } { p.SetState(1054) - p.Match(YQLv1Antlr4ParserIN) + p.Match(YQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7327,7 +7327,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 { { p.SetState(1055) - p.Match(YQLv1Antlr4ParserCOMPACT) + p.Match(YQLParserCOMPACT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7355,7 +7355,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { case 1: { p.SetState(1059) - p.Match(YQLv1Antlr4ParserISNULL) + p.Match(YQLParserISNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7366,7 +7366,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { case 2: { p.SetState(1060) - p.Match(YQLv1Antlr4ParserNOTNULL) + p.Match(YQLParserNOTNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7377,7 +7377,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { case 3: { p.SetState(1061) - p.Match(YQLv1Antlr4ParserIS) + p.Match(YQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7385,7 +7385,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } { p.SetState(1062) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7402,10 +7402,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserIS { + if _la == YQLParserIS { { p.SetState(1063) - p.Match(YQLv1Antlr4ParserIS) + p.Match(YQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7415,7 +7415,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } { p.SetState(1066) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7423,7 +7423,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } { p.SetState(1067) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7445,10 +7445,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT { + if _la == YQLParserNOT { { p.SetState(1070) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7458,7 +7458,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } { p.SetState(1073) - p.Match(YQLv1Antlr4ParserBETWEEN) + p.Match(YQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7473,7 +7473,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { p.SetState(1074) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserASYMMETRIC || _la == YQLv1Antlr4ParserSYMMETRIC) { + if !(_la == YQLParserASYMMETRIC || _la == YQLParserSYMMETRIC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -7490,7 +7490,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } { p.SetState(1078) - p.Match(YQLv1Antlr4ParserAND) + p.Match(YQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7520,10 +7520,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserEQUALS: + case YQLParserEQUALS: { p.SetState(1081) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7531,10 +7531,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } - case YQLv1Antlr4ParserEQUALS2: + case YQLParserEQUALS2: { p.SetState(1082) - p.Match(YQLv1Antlr4ParserEQUALS2) + p.Match(YQLParserEQUALS2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7542,10 +7542,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } - case YQLv1Antlr4ParserNOT_EQUALS: + case YQLParserNOT_EQUALS: { p.SetState(1083) - p.Match(YQLv1Antlr4ParserNOT_EQUALS) + p.Match(YQLParserNOT_EQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7553,10 +7553,10 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } - case YQLv1Antlr4ParserNOT_EQUALS2: + case YQLParserNOT_EQUALS2: { p.SetState(1084) - p.Match(YQLv1Antlr4ParserNOT_EQUALS2) + p.Match(YQLParserNOT_EQUALS2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -7564,7 +7564,7 @@ func (p *YQLv1Antlr4Parser) Cond_expr() (localctx ICond_exprContext) { } - case YQLv1Antlr4ParserIS: + case YQLParserIS: { p.SetState(1085) p.Distinct_from_op() @@ -7643,13 +7643,13 @@ type Match_opContext struct { func NewEmptyMatch_opContext() *Match_opContext { var p = new(Match_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_match_op + p.RuleIndex = YQLParserRULE_match_op return p } func InitEmptyMatch_opContext(p *Match_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_match_op + p.RuleIndex = YQLParserRULE_match_op } func (*Match_opContext) IsMatch_opContext() {} @@ -7660,7 +7660,7 @@ func NewMatch_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_match_op + p.RuleIndex = YQLParserRULE_match_op return p } @@ -7668,27 +7668,27 @@ func NewMatch_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *Match_opContext) GetParser() antlr.Parser { return s.parser } func (s *Match_opContext) LIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIKE, 0) + return s.GetToken(YQLParserLIKE, 0) } func (s *Match_opContext) ILIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserILIKE, 0) + return s.GetToken(YQLParserILIKE, 0) } func (s *Match_opContext) GLOB() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGLOB, 0) + return s.GetToken(YQLParserGLOB, 0) } func (s *Match_opContext) REGEXP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREGEXP, 0) + return s.GetToken(YQLParserREGEXP, 0) } func (s *Match_opContext) RLIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRLIKE, 0) + return s.GetToken(YQLParserRLIKE, 0) } func (s *Match_opContext) MATCH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH, 0) + return s.GetToken(YQLParserMATCH, 0) } func (s *Match_opContext) GetRuleContext() antlr.RuleContext { @@ -7701,13 +7701,13 @@ func (s *Match_opContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *Match_opContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterMatch_op(s) } } func (s *Match_opContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitMatch_op(s) } } @@ -7715,9 +7715,9 @@ func (s *Match_opContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Match_op() (localctx IMatch_opContext) { +func (p *YQLParser) Match_op() (localctx IMatch_opContext) { localctx = NewMatch_opContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 26, YQLv1Antlr4ParserRULE_match_op) + p.EnterRule(localctx, 26, YQLParserRULE_match_op) var _la int p.EnterOuterAlt(localctx, 1) @@ -7725,7 +7725,7 @@ func (p *YQLv1Antlr4Parser) Match_op() (localctx IMatch_opContext) { p.SetState(1095) _la = p.GetTokenStream().LA(1) - if !(((int64((_la - 143)) & ^0x3f) == 0 && ((int64(1) << (_la - 143)) & 8933531977729) != 0) || _la == YQLv1Antlr4ParserREGEXP || _la == YQLv1Antlr4ParserRLIKE) { + if !(((int64((_la - 143)) & ^0x3f) == 0 && ((int64(1) << (_la - 143)) & 8933531977729) != 0) || _la == YQLParserREGEXP || _la == YQLParserRLIKE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -7780,13 +7780,13 @@ type Eq_subexprContext struct { func NewEmptyEq_subexprContext() *Eq_subexprContext { var p = new(Eq_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_eq_subexpr + p.RuleIndex = YQLParserRULE_eq_subexpr return p } func InitEmptyEq_subexprContext(p *Eq_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_eq_subexpr + p.RuleIndex = YQLParserRULE_eq_subexpr } func (*Eq_subexprContext) IsEq_subexprContext() {} @@ -7797,7 +7797,7 @@ func NewEq_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_eq_subexpr + p.RuleIndex = YQLParserRULE_eq_subexpr return p } @@ -7846,35 +7846,35 @@ func (s *Eq_subexprContext) Neq_subexpr(i int) INeq_subexprContext { } func (s *Eq_subexprContext) AllLESS() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserLESS) + return s.GetTokens(YQLParserLESS) } func (s *Eq_subexprContext) LESS(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, i) + return s.GetToken(YQLParserLESS, i) } func (s *Eq_subexprContext) AllLESS_OR_EQ() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserLESS_OR_EQ) + return s.GetTokens(YQLParserLESS_OR_EQ) } func (s *Eq_subexprContext) LESS_OR_EQ(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS_OR_EQ, i) + return s.GetToken(YQLParserLESS_OR_EQ, i) } func (s *Eq_subexprContext) AllGREATER() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserGREATER) + return s.GetTokens(YQLParserGREATER) } func (s *Eq_subexprContext) GREATER(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, i) + return s.GetToken(YQLParserGREATER, i) } func (s *Eq_subexprContext) AllGREATER_OR_EQ() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserGREATER_OR_EQ) + return s.GetTokens(YQLParserGREATER_OR_EQ) } func (s *Eq_subexprContext) GREATER_OR_EQ(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER_OR_EQ, i) + return s.GetToken(YQLParserGREATER_OR_EQ, i) } func (s *Eq_subexprContext) GetRuleContext() antlr.RuleContext { @@ -7887,13 +7887,13 @@ func (s *Eq_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Eq_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterEq_subexpr(s) } } func (s *Eq_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitEq_subexpr(s) } } @@ -7901,9 +7901,9 @@ func (s *Eq_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Eq_subexpr() (localctx IEq_subexprContext) { +func (p *YQLParser) Eq_subexpr() (localctx IEq_subexprContext) { localctx = NewEq_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 28, YQLv1Antlr4ParserRULE_eq_subexpr) + p.EnterRule(localctx, 28, YQLParserRULE_eq_subexpr) var _la int p.EnterOuterAlt(localctx, 1) @@ -7984,13 +7984,13 @@ type Shift_rightContext struct { func NewEmptyShift_rightContext() *Shift_rightContext { var p = new(Shift_rightContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_shift_right + p.RuleIndex = YQLParserRULE_shift_right return p } func InitEmptyShift_rightContext(p *Shift_rightContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_shift_right + p.RuleIndex = YQLParserRULE_shift_right } func (*Shift_rightContext) IsShift_rightContext() {} @@ -8001,7 +8001,7 @@ func NewShift_rightContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_shift_right + p.RuleIndex = YQLParserRULE_shift_right return p } @@ -8009,11 +8009,11 @@ func NewShift_rightContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Shift_rightContext) GetParser() antlr.Parser { return s.parser } func (s *Shift_rightContext) AllGREATER() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserGREATER) + return s.GetTokens(YQLParserGREATER) } func (s *Shift_rightContext) GREATER(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, i) + return s.GetToken(YQLParserGREATER, i) } func (s *Shift_rightContext) GetRuleContext() antlr.RuleContext { @@ -8026,13 +8026,13 @@ func (s *Shift_rightContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Shift_rightContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterShift_right(s) } } func (s *Shift_rightContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitShift_right(s) } } @@ -8040,13 +8040,13 @@ func (s *Shift_rightContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Shift_right() (localctx IShift_rightContext) { +func (p *YQLParser) Shift_right() (localctx IShift_rightContext) { localctx = NewShift_rightContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 30, YQLv1Antlr4ParserRULE_shift_right) + p.EnterRule(localctx, 30, YQLParserRULE_shift_right) p.EnterOuterAlt(localctx, 1) { p.SetState(1105) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8054,7 +8054,7 @@ func (p *YQLv1Antlr4Parser) Shift_right() (localctx IShift_rightContext) { } { p.SetState(1106) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8101,13 +8101,13 @@ type Rot_rightContext struct { func NewEmptyRot_rightContext() *Rot_rightContext { var p = new(Rot_rightContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_rot_right + p.RuleIndex = YQLParserRULE_rot_right return p } func InitEmptyRot_rightContext(p *Rot_rightContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_rot_right + p.RuleIndex = YQLParserRULE_rot_right } func (*Rot_rightContext) IsRot_rightContext() {} @@ -8118,7 +8118,7 @@ func NewRot_rightContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_rot_right + p.RuleIndex = YQLParserRULE_rot_right return p } @@ -8126,15 +8126,15 @@ func NewRot_rightContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *Rot_rightContext) GetParser() antlr.Parser { return s.parser } func (s *Rot_rightContext) AllGREATER() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserGREATER) + return s.GetTokens(YQLParserGREATER) } func (s *Rot_rightContext) GREATER(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, i) + return s.GetToken(YQLParserGREATER, i) } func (s *Rot_rightContext) PIPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPIPE, 0) + return s.GetToken(YQLParserPIPE, 0) } func (s *Rot_rightContext) GetRuleContext() antlr.RuleContext { @@ -8147,13 +8147,13 @@ func (s *Rot_rightContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Rot_rightContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRot_right(s) } } func (s *Rot_rightContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRot_right(s) } } @@ -8161,13 +8161,13 @@ func (s *Rot_rightContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Rot_right() (localctx IRot_rightContext) { +func (p *YQLParser) Rot_right() (localctx IRot_rightContext) { localctx = NewRot_rightContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 32, YQLv1Antlr4ParserRULE_rot_right) + p.EnterRule(localctx, 32, YQLParserRULE_rot_right) p.EnterOuterAlt(localctx, 1) { p.SetState(1108) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8175,7 +8175,7 @@ func (p *YQLv1Antlr4Parser) Rot_right() (localctx IRot_rightContext) { } { p.SetState(1109) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8183,7 +8183,7 @@ func (p *YQLv1Antlr4Parser) Rot_right() (localctx IRot_rightContext) { } { p.SetState(1110) - p.Match(YQLv1Antlr4ParserPIPE) + p.Match(YQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8229,13 +8229,13 @@ type Double_questionContext struct { func NewEmptyDouble_questionContext() *Double_questionContext { var p = new(Double_questionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_double_question + p.RuleIndex = YQLParserRULE_double_question return p } func InitEmptyDouble_questionContext(p *Double_questionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_double_question + p.RuleIndex = YQLParserRULE_double_question } func (*Double_questionContext) IsDouble_questionContext() {} @@ -8246,7 +8246,7 @@ func NewDouble_questionContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_double_question + p.RuleIndex = YQLParserRULE_double_question return p } @@ -8254,11 +8254,11 @@ func NewDouble_questionContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Double_questionContext) GetParser() antlr.Parser { return s.parser } func (s *Double_questionContext) AllQUESTION() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserQUESTION) + return s.GetTokens(YQLParserQUESTION) } func (s *Double_questionContext) QUESTION(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUESTION, i) + return s.GetToken(YQLParserQUESTION, i) } func (s *Double_questionContext) GetRuleContext() antlr.RuleContext { @@ -8271,13 +8271,13 @@ func (s *Double_questionContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Double_questionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDouble_question(s) } } func (s *Double_questionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDouble_question(s) } } @@ -8285,13 +8285,13 @@ func (s *Double_questionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Double_question() (localctx IDouble_questionContext) { +func (p *YQLParser) Double_question() (localctx IDouble_questionContext) { localctx = NewDouble_questionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 34, YQLv1Antlr4ParserRULE_double_question) + p.EnterRule(localctx, 34, YQLParserRULE_double_question) p.EnterOuterAlt(localctx, 1) { p.SetState(1112) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8299,7 +8299,7 @@ func (p *YQLv1Antlr4Parser) Double_question() (localctx IDouble_questionContext) } { p.SetState(1113) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8363,13 +8363,13 @@ type Neq_subexprContext struct { func NewEmptyNeq_subexprContext() *Neq_subexprContext { var p = new(Neq_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_neq_subexpr + p.RuleIndex = YQLParserRULE_neq_subexpr return p } func InitEmptyNeq_subexprContext(p *Neq_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_neq_subexpr + p.RuleIndex = YQLParserRULE_neq_subexpr } func (*Neq_subexprContext) IsNeq_subexprContext() {} @@ -8380,7 +8380,7 @@ func NewNeq_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_neq_subexpr + p.RuleIndex = YQLParserRULE_neq_subexpr return p } @@ -8461,11 +8461,11 @@ func (s *Neq_subexprContext) Neq_subexpr() INeq_subexprContext { } func (s *Neq_subexprContext) AllSHIFT_LEFT() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserSHIFT_LEFT) + return s.GetTokens(YQLParserSHIFT_LEFT) } func (s *Neq_subexprContext) SHIFT_LEFT(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSHIFT_LEFT, i) + return s.GetToken(YQLParserSHIFT_LEFT, i) } func (s *Neq_subexprContext) AllShift_right() []IShift_rightContext { @@ -8510,11 +8510,11 @@ func (s *Neq_subexprContext) Shift_right(i int) IShift_rightContext { } func (s *Neq_subexprContext) AllROT_LEFT() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserROT_LEFT) + return s.GetTokens(YQLParserROT_LEFT) } func (s *Neq_subexprContext) ROT_LEFT(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROT_LEFT, i) + return s.GetToken(YQLParserROT_LEFT, i) } func (s *Neq_subexprContext) AllRot_right() []IRot_rightContext { @@ -8559,35 +8559,35 @@ func (s *Neq_subexprContext) Rot_right(i int) IRot_rightContext { } func (s *Neq_subexprContext) AllAMPERSAND() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserAMPERSAND) + return s.GetTokens(YQLParserAMPERSAND) } func (s *Neq_subexprContext) AMPERSAND(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAMPERSAND, i) + return s.GetToken(YQLParserAMPERSAND, i) } func (s *Neq_subexprContext) AllPIPE() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserPIPE) + return s.GetTokens(YQLParserPIPE) } func (s *Neq_subexprContext) PIPE(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPIPE, i) + return s.GetToken(YQLParserPIPE, i) } func (s *Neq_subexprContext) AllCARET() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCARET) + return s.GetTokens(YQLParserCARET) } func (s *Neq_subexprContext) CARET(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCARET, i) + return s.GetToken(YQLParserCARET, i) } func (s *Neq_subexprContext) AllQUESTION() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserQUESTION) + return s.GetTokens(YQLParserQUESTION) } func (s *Neq_subexprContext) QUESTION(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUESTION, i) + return s.GetToken(YQLParserQUESTION, i) } func (s *Neq_subexprContext) GetRuleContext() antlr.RuleContext { @@ -8600,13 +8600,13 @@ func (s *Neq_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Neq_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNeq_subexpr(s) } } func (s *Neq_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNeq_subexpr(s) } } @@ -8614,9 +8614,9 @@ func (s *Neq_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Neq_subexpr() (localctx INeq_subexprContext) { +func (p *YQLParser) Neq_subexpr() (localctx INeq_subexprContext) { localctx = NewNeq_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 36, YQLv1Antlr4ParserRULE_neq_subexpr) + p.EnterRule(localctx, 36, YQLParserRULE_neq_subexpr) var _la int var _alt int @@ -8647,7 +8647,7 @@ func (p *YQLv1Antlr4Parser) Neq_subexpr() (localctx INeq_subexprContext) { case 1: { p.SetState(1116) - p.Match(YQLv1Antlr4ParserSHIFT_LEFT) + p.Match(YQLParserSHIFT_LEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8665,7 +8665,7 @@ func (p *YQLv1Antlr4Parser) Neq_subexpr() (localctx INeq_subexprContext) { case 3: { p.SetState(1118) - p.Match(YQLv1Antlr4ParserROT_LEFT) + p.Match(YQLParserROT_LEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8683,7 +8683,7 @@ func (p *YQLv1Antlr4Parser) Neq_subexpr() (localctx INeq_subexprContext) { case 5: { p.SetState(1120) - p.Match(YQLv1Antlr4ParserAMPERSAND) + p.Match(YQLParserAMPERSAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8694,7 +8694,7 @@ func (p *YQLv1Antlr4Parser) Neq_subexpr() (localctx INeq_subexprContext) { case 6: { p.SetState(1121) - p.Match(YQLv1Antlr4ParserPIPE) + p.Match(YQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8705,7 +8705,7 @@ func (p *YQLv1Antlr4Parser) Neq_subexpr() (localctx INeq_subexprContext) { case 7: { p.SetState(1122) - p.Match(YQLv1Antlr4ParserCARET) + p.Match(YQLParserCARET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8756,10 +8756,10 @@ func (p *YQLv1Antlr4Parser) Neq_subexpr() (localctx INeq_subexprContext) { _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == YQLv1Antlr4ParserQUESTION { + for ok := true; ok; ok = _la == YQLParserQUESTION { { p.SetState(1134) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -8822,13 +8822,13 @@ type Bit_subexprContext struct { func NewEmptyBit_subexprContext() *Bit_subexprContext { var p = new(Bit_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bit_subexpr + p.RuleIndex = YQLParserRULE_bit_subexpr return p } func InitEmptyBit_subexprContext(p *Bit_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bit_subexpr + p.RuleIndex = YQLParserRULE_bit_subexpr } func (*Bit_subexprContext) IsBit_subexprContext() {} @@ -8839,7 +8839,7 @@ func NewBit_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_bit_subexpr + p.RuleIndex = YQLParserRULE_bit_subexpr return p } @@ -8888,19 +8888,19 @@ func (s *Bit_subexprContext) Add_subexpr(i int) IAdd_subexprContext { } func (s *Bit_subexprContext) AllPLUS() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserPLUS) + return s.GetTokens(YQLParserPLUS) } func (s *Bit_subexprContext) PLUS(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPLUS, i) + return s.GetToken(YQLParserPLUS, i) } func (s *Bit_subexprContext) AllMINUS() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserMINUS) + return s.GetTokens(YQLParserMINUS) } func (s *Bit_subexprContext) MINUS(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMINUS, i) + return s.GetToken(YQLParserMINUS, i) } func (s *Bit_subexprContext) GetRuleContext() antlr.RuleContext { @@ -8913,13 +8913,13 @@ func (s *Bit_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Bit_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBit_subexpr(s) } } func (s *Bit_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBit_subexpr(s) } } @@ -8927,9 +8927,9 @@ func (s *Bit_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Bit_subexpr() (localctx IBit_subexprContext) { +func (p *YQLParser) Bit_subexpr() (localctx IBit_subexprContext) { localctx = NewBit_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 38, YQLv1Antlr4ParserRULE_bit_subexpr) + p.EnterRule(localctx, 38, YQLParserRULE_bit_subexpr) var _la int p.EnterOuterAlt(localctx, 1) @@ -8945,12 +8945,12 @@ func (p *YQLv1Antlr4Parser) Bit_subexpr() (localctx IBit_subexprContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserPLUS || _la == YQLv1Antlr4ParserMINUS { + for _la == YQLParserPLUS || _la == YQLParserMINUS { { p.SetState(1142) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserPLUS || _la == YQLv1Antlr4ParserMINUS) { + if !(_la == YQLParserPLUS || _la == YQLParserMINUS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -9016,13 +9016,13 @@ type Add_subexprContext struct { func NewEmptyAdd_subexprContext() *Add_subexprContext { var p = new(Add_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_add_subexpr + p.RuleIndex = YQLParserRULE_add_subexpr return p } func InitEmptyAdd_subexprContext(p *Add_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_add_subexpr + p.RuleIndex = YQLParserRULE_add_subexpr } func (*Add_subexprContext) IsAdd_subexprContext() {} @@ -9033,7 +9033,7 @@ func NewAdd_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_add_subexpr + p.RuleIndex = YQLParserRULE_add_subexpr return p } @@ -9082,27 +9082,27 @@ func (s *Add_subexprContext) Mul_subexpr(i int) IMul_subexprContext { } func (s *Add_subexprContext) AllASTERISK() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserASTERISK) + return s.GetTokens(YQLParserASTERISK) } func (s *Add_subexprContext) ASTERISK(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASTERISK, i) + return s.GetToken(YQLParserASTERISK, i) } func (s *Add_subexprContext) AllSLASH() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserSLASH) + return s.GetTokens(YQLParserSLASH) } func (s *Add_subexprContext) SLASH(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSLASH, i) + return s.GetToken(YQLParserSLASH, i) } func (s *Add_subexprContext) AllPERCENT() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserPERCENT) + return s.GetTokens(YQLParserPERCENT) } func (s *Add_subexprContext) PERCENT(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPERCENT, i) + return s.GetToken(YQLParserPERCENT, i) } func (s *Add_subexprContext) GetRuleContext() antlr.RuleContext { @@ -9115,13 +9115,13 @@ func (s *Add_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Add_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAdd_subexpr(s) } } func (s *Add_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAdd_subexpr(s) } } @@ -9129,9 +9129,9 @@ func (s *Add_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Add_subexpr() (localctx IAdd_subexprContext) { +func (p *YQLParser) Add_subexpr() (localctx IAdd_subexprContext) { localctx = NewAdd_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 40, YQLv1Antlr4ParserRULE_add_subexpr) + p.EnterRule(localctx, 40, YQLParserRULE_add_subexpr) var _la int p.EnterOuterAlt(localctx, 1) @@ -9214,13 +9214,13 @@ type Mul_subexprContext struct { func NewEmptyMul_subexprContext() *Mul_subexprContext { var p = new(Mul_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_mul_subexpr + p.RuleIndex = YQLParserRULE_mul_subexpr return p } func InitEmptyMul_subexprContext(p *Mul_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_mul_subexpr + p.RuleIndex = YQLParserRULE_mul_subexpr } func (*Mul_subexprContext) IsMul_subexprContext() {} @@ -9231,7 +9231,7 @@ func NewMul_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_mul_subexpr + p.RuleIndex = YQLParserRULE_mul_subexpr return p } @@ -9280,11 +9280,11 @@ func (s *Mul_subexprContext) Con_subexpr(i int) ICon_subexprContext { } func (s *Mul_subexprContext) AllDOUBLE_PIPE() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserDOUBLE_PIPE) + return s.GetTokens(YQLParserDOUBLE_PIPE) } func (s *Mul_subexprContext) DOUBLE_PIPE(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOUBLE_PIPE, i) + return s.GetToken(YQLParserDOUBLE_PIPE, i) } func (s *Mul_subexprContext) GetRuleContext() antlr.RuleContext { @@ -9297,13 +9297,13 @@ func (s *Mul_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Mul_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterMul_subexpr(s) } } func (s *Mul_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitMul_subexpr(s) } } @@ -9311,9 +9311,9 @@ func (s *Mul_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Mul_subexpr() (localctx IMul_subexprContext) { +func (p *YQLParser) Mul_subexpr() (localctx IMul_subexprContext) { localctx = NewMul_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 42, YQLv1Antlr4ParserRULE_mul_subexpr) + p.EnterRule(localctx, 42, YQLParserRULE_mul_subexpr) var _la int p.EnterOuterAlt(localctx, 1) @@ -9329,10 +9329,10 @@ func (p *YQLv1Antlr4Parser) Mul_subexpr() (localctx IMul_subexprContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserDOUBLE_PIPE { + for _la == YQLParserDOUBLE_PIPE { { p.SetState(1158) - p.Match(YQLv1Antlr4ParserDOUBLE_PIPE) + p.Match(YQLParserDOUBLE_PIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -9391,13 +9391,13 @@ type Con_subexprContext struct { func NewEmptyCon_subexprContext() *Con_subexprContext { var p = new(Con_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_con_subexpr + p.RuleIndex = YQLParserRULE_con_subexpr return p } func InitEmptyCon_subexprContext(p *Con_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_con_subexpr + p.RuleIndex = YQLParserRULE_con_subexpr } func (*Con_subexprContext) IsCon_subexprContext() {} @@ -9408,7 +9408,7 @@ func NewCon_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_con_subexpr + p.RuleIndex = YQLParserRULE_con_subexpr return p } @@ -9457,13 +9457,13 @@ func (s *Con_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Con_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCon_subexpr(s) } } func (s *Con_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCon_subexpr(s) } } @@ -9471,9 +9471,9 @@ func (s *Con_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Con_subexpr() (localctx ICon_subexprContext) { +func (p *YQLParser) Con_subexpr() (localctx ICon_subexprContext) { localctx = NewCon_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 44, YQLv1Antlr4ParserRULE_con_subexpr) + p.EnterRule(localctx, 44, YQLParserRULE_con_subexpr) p.SetState(1169) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -9544,13 +9544,13 @@ type Unary_opContext struct { func NewEmptyUnary_opContext() *Unary_opContext { var p = new(Unary_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_op + p.RuleIndex = YQLParserRULE_unary_op return p } func InitEmptyUnary_opContext(p *Unary_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_op + p.RuleIndex = YQLParserRULE_unary_op } func (*Unary_opContext) IsUnary_opContext() {} @@ -9561,7 +9561,7 @@ func NewUnary_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_op + p.RuleIndex = YQLParserRULE_unary_op return p } @@ -9569,19 +9569,19 @@ func NewUnary_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *Unary_opContext) GetParser() antlr.Parser { return s.parser } func (s *Unary_opContext) PLUS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPLUS, 0) + return s.GetToken(YQLParserPLUS, 0) } func (s *Unary_opContext) MINUS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMINUS, 0) + return s.GetToken(YQLParserMINUS, 0) } func (s *Unary_opContext) TILDA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTILDA, 0) + return s.GetToken(YQLParserTILDA, 0) } func (s *Unary_opContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Unary_opContext) GetRuleContext() antlr.RuleContext { @@ -9594,13 +9594,13 @@ func (s *Unary_opContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *Unary_opContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUnary_op(s) } } func (s *Unary_opContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUnary_op(s) } } @@ -9608,9 +9608,9 @@ func (s *Unary_opContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Unary_op() (localctx IUnary_opContext) { +func (p *YQLParser) Unary_op() (localctx IUnary_opContext) { localctx = NewUnary_opContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 46, YQLv1Antlr4ParserRULE_unary_op) + p.EnterRule(localctx, 46, YQLParserRULE_unary_op) var _la int p.EnterOuterAlt(localctx, 1) @@ -9618,7 +9618,7 @@ func (p *YQLv1Antlr4Parser) Unary_op() (localctx IUnary_opContext) { p.SetState(1171) _la = p.GetTokenStream().LA(1) - if !(((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 458752) != 0) || _la == YQLv1Antlr4ParserNOT) { + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 458752) != 0) || _la == YQLParserNOT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -9677,13 +9677,13 @@ type Unary_subexpr_suffixContext struct { func NewEmptyUnary_subexpr_suffixContext() *Unary_subexpr_suffixContext { var p = new(Unary_subexpr_suffixContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_subexpr_suffix + p.RuleIndex = YQLParserRULE_unary_subexpr_suffix return p } func InitEmptyUnary_subexpr_suffixContext(p *Unary_subexpr_suffixContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_subexpr_suffix + p.RuleIndex = YQLParserRULE_unary_subexpr_suffix } func (*Unary_subexpr_suffixContext) IsUnary_subexpr_suffixContext() {} @@ -9694,7 +9694,7 @@ func NewUnary_subexpr_suffixContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_subexpr_suffix + p.RuleIndex = YQLParserRULE_unary_subexpr_suffix return p } @@ -9702,7 +9702,7 @@ func NewUnary_subexpr_suffixContext(parser antlr.Parser, parent antlr.ParserRule func (s *Unary_subexpr_suffixContext) GetParser() antlr.Parser { return s.parser } func (s *Unary_subexpr_suffixContext) COLLATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLLATE, 0) + return s.GetToken(YQLParserCOLLATE, 0) } func (s *Unary_subexpr_suffixContext) An_id() IAn_idContext { @@ -9804,11 +9804,11 @@ func (s *Unary_subexpr_suffixContext) Invoke_expr(i int) IInvoke_exprContext { } func (s *Unary_subexpr_suffixContext) AllDOT() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserDOT) + return s.GetTokens(YQLParserDOT) } func (s *Unary_subexpr_suffixContext) DOT(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, i) + return s.GetToken(YQLParserDOT, i) } func (s *Unary_subexpr_suffixContext) AllBind_parameter() []IBind_parameterContext { @@ -9853,11 +9853,11 @@ func (s *Unary_subexpr_suffixContext) Bind_parameter(i int) IBind_parameterConte } func (s *Unary_subexpr_suffixContext) AllDIGITS() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserDIGITS) + return s.GetTokens(YQLParserDIGITS) } func (s *Unary_subexpr_suffixContext) DIGITS(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDIGITS, i) + return s.GetToken(YQLParserDIGITS, i) } func (s *Unary_subexpr_suffixContext) AllAn_id_or_type() []IAn_id_or_typeContext { @@ -9911,13 +9911,13 @@ func (s *Unary_subexpr_suffixContext) ToStringTree(ruleNames []string, recog ant func (s *Unary_subexpr_suffixContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUnary_subexpr_suffix(s) } } func (s *Unary_subexpr_suffixContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUnary_subexpr_suffix(s) } } @@ -9925,9 +9925,9 @@ func (s *Unary_subexpr_suffixContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Unary_subexpr_suffix() (localctx IUnary_subexpr_suffixContext) { +func (p *YQLParser) Unary_subexpr_suffix() (localctx IUnary_subexpr_suffixContext) { localctx = NewUnary_subexpr_suffixContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 48, YQLv1Antlr4ParserRULE_unary_subexpr_suffix) + p.EnterRule(localctx, 48, YQLParserRULE_unary_subexpr_suffix) var _la int p.EnterOuterAlt(localctx, 1) @@ -9947,24 +9947,24 @@ func (p *YQLv1Antlr4Parser) Unary_subexpr_suffix() (localctx IUnary_subexpr_suff } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLBRACE_SQUARE: + case YQLParserLBRACE_SQUARE: { p.SetState(1173) p.Key_expr() } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: { p.SetState(1174) p.Invoke_expr() } - case YQLv1Antlr4ParserDOT: + case YQLParserDOT: { p.SetState(1175) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -9977,17 +9977,17 @@ func (p *YQLv1Antlr4Parser) Unary_subexpr_suffix() (localctx IUnary_subexpr_suff } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: { p.SetState(1176) p.Bind_parameter() } - case YQLv1Antlr4ParserDIGITS: + case YQLParserDIGITS: { p.SetState(1177) - p.Match(YQLv1Antlr4ParserDIGITS) + p.Match(YQLParserDIGITS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -9995,7 +9995,7 @@ func (p *YQLv1Antlr4Parser) Unary_subexpr_suffix() (localctx IUnary_subexpr_suff } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(1178) p.An_id_or_type() @@ -10031,10 +10031,10 @@ func (p *YQLv1Antlr4Parser) Unary_subexpr_suffix() (localctx IUnary_subexpr_suff _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOLLATE { + if _la == YQLParserCOLLATE { { p.SetState(1188) - p.Match(YQLv1Antlr4ParserCOLLATE) + p.Match(YQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -10087,13 +10087,13 @@ type Unary_casual_subexprContext struct { func NewEmptyUnary_casual_subexprContext() *Unary_casual_subexprContext { var p = new(Unary_casual_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_casual_subexpr + p.RuleIndex = YQLParserRULE_unary_casual_subexpr return p } func InitEmptyUnary_casual_subexprContext(p *Unary_casual_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_casual_subexpr + p.RuleIndex = YQLParserRULE_unary_casual_subexpr } func (*Unary_casual_subexprContext) IsUnary_casual_subexprContext() {} @@ -10104,7 +10104,7 @@ func NewUnary_casual_subexprContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_casual_subexpr + p.RuleIndex = YQLParserRULE_unary_casual_subexpr return p } @@ -10169,13 +10169,13 @@ func (s *Unary_casual_subexprContext) ToStringTree(ruleNames []string, recog ant func (s *Unary_casual_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUnary_casual_subexpr(s) } } func (s *Unary_casual_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUnary_casual_subexpr(s) } } @@ -10183,9 +10183,9 @@ func (s *Unary_casual_subexprContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Unary_casual_subexpr() (localctx IUnary_casual_subexprContext) { +func (p *YQLParser) Unary_casual_subexpr() (localctx IUnary_casual_subexprContext) { localctx = NewUnary_casual_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 50, YQLv1Antlr4ParserRULE_unary_casual_subexpr) + p.EnterRule(localctx, 50, YQLParserRULE_unary_casual_subexpr) p.EnterOuterAlt(localctx, 1) p.SetState(1194) p.GetErrorHandler().Sync(p) @@ -10255,13 +10255,13 @@ type In_unary_casual_subexprContext struct { func NewEmptyIn_unary_casual_subexprContext() *In_unary_casual_subexprContext { var p = new(In_unary_casual_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_unary_casual_subexpr + p.RuleIndex = YQLParserRULE_in_unary_casual_subexpr return p } func InitEmptyIn_unary_casual_subexprContext(p *In_unary_casual_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_unary_casual_subexpr + p.RuleIndex = YQLParserRULE_in_unary_casual_subexpr } func (*In_unary_casual_subexprContext) IsIn_unary_casual_subexprContext() {} @@ -10272,7 +10272,7 @@ func NewIn_unary_casual_subexprContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_in_unary_casual_subexpr + p.RuleIndex = YQLParserRULE_in_unary_casual_subexpr return p } @@ -10337,13 +10337,13 @@ func (s *In_unary_casual_subexprContext) ToStringTree(ruleNames []string, recog func (s *In_unary_casual_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIn_unary_casual_subexpr(s) } } func (s *In_unary_casual_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIn_unary_casual_subexpr(s) } } @@ -10351,9 +10351,9 @@ func (s *In_unary_casual_subexprContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) In_unary_casual_subexpr() (localctx IIn_unary_casual_subexprContext) { +func (p *YQLParser) In_unary_casual_subexpr() (localctx IIn_unary_casual_subexprContext) { localctx = NewIn_unary_casual_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 52, YQLv1Antlr4ParserRULE_in_unary_casual_subexpr) + p.EnterRule(localctx, 52, YQLParserRULE_in_unary_casual_subexpr) p.EnterOuterAlt(localctx, 1) p.SetState(1200) p.GetErrorHandler().Sync(p) @@ -10422,13 +10422,13 @@ type Unary_subexprContext struct { func NewEmptyUnary_subexprContext() *Unary_subexprContext { var p = new(Unary_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_subexpr + p.RuleIndex = YQLParserRULE_unary_subexpr return p } func InitEmptyUnary_subexprContext(p *Unary_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_subexpr + p.RuleIndex = YQLParserRULE_unary_subexpr } func (*Unary_subexprContext) IsUnary_subexprContext() {} @@ -10439,7 +10439,7 @@ func NewUnary_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_unary_subexpr + p.RuleIndex = YQLParserRULE_unary_subexpr return p } @@ -10488,13 +10488,13 @@ func (s *Unary_subexprContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Unary_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUnary_subexpr(s) } } func (s *Unary_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUnary_subexpr(s) } } @@ -10502,9 +10502,9 @@ func (s *Unary_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Unary_subexpr() (localctx IUnary_subexprContext) { +func (p *YQLParser) Unary_subexpr() (localctx IUnary_subexprContext) { localctx = NewUnary_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 54, YQLv1Antlr4ParserRULE_unary_subexpr) + p.EnterRule(localctx, 54, YQLParserRULE_unary_subexpr) p.SetState(1206) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -10569,13 +10569,13 @@ type In_unary_subexprContext struct { func NewEmptyIn_unary_subexprContext() *In_unary_subexprContext { var p = new(In_unary_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_unary_subexpr + p.RuleIndex = YQLParserRULE_in_unary_subexpr return p } func InitEmptyIn_unary_subexprContext(p *In_unary_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_unary_subexpr + p.RuleIndex = YQLParserRULE_in_unary_subexpr } func (*In_unary_subexprContext) IsIn_unary_subexprContext() {} @@ -10586,7 +10586,7 @@ func NewIn_unary_subexprContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_in_unary_subexpr + p.RuleIndex = YQLParserRULE_in_unary_subexpr return p } @@ -10635,13 +10635,13 @@ func (s *In_unary_subexprContext) ToStringTree(ruleNames []string, recog antlr.R func (s *In_unary_subexprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIn_unary_subexpr(s) } } func (s *In_unary_subexprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIn_unary_subexpr(s) } } @@ -10649,9 +10649,9 @@ func (s *In_unary_subexprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) In_unary_subexpr() (localctx IIn_unary_subexprContext) { +func (p *YQLParser) In_unary_subexpr() (localctx IIn_unary_subexprContext) { localctx = NewIn_unary_subexprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 56, YQLv1Antlr4ParserRULE_in_unary_subexpr) + p.EnterRule(localctx, 56, YQLParserRULE_in_unary_subexpr) p.SetState(1210) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -10718,13 +10718,13 @@ type List_literalContext struct { func NewEmptyList_literalContext() *List_literalContext { var p = new(List_literalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_list_literal + p.RuleIndex = YQLParserRULE_list_literal return p } func InitEmptyList_literalContext(p *List_literalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_list_literal + p.RuleIndex = YQLParserRULE_list_literal } func (*List_literalContext) IsList_literalContext() {} @@ -10735,7 +10735,7 @@ func NewList_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_list_literal + p.RuleIndex = YQLParserRULE_list_literal return p } @@ -10743,11 +10743,11 @@ func NewList_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *List_literalContext) GetParser() antlr.Parser { return s.parser } func (s *List_literalContext) LBRACE_SQUARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_SQUARE, 0) + return s.GetToken(YQLParserLBRACE_SQUARE, 0) } func (s *List_literalContext) RBRACE_SQUARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_SQUARE, 0) + return s.GetToken(YQLParserRBRACE_SQUARE, 0) } func (s *List_literalContext) Expr_list() IExpr_listContext { @@ -10767,7 +10767,7 @@ func (s *List_literalContext) Expr_list() IExpr_listContext { } func (s *List_literalContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *List_literalContext) GetRuleContext() antlr.RuleContext { @@ -10780,13 +10780,13 @@ func (s *List_literalContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *List_literalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterList_literal(s) } } func (s *List_literalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitList_literal(s) } } @@ -10794,15 +10794,15 @@ func (s *List_literalContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) List_literal() (localctx IList_literalContext) { +func (p *YQLParser) List_literal() (localctx IList_literalContext) { localctx = NewList_literalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 58, YQLv1Antlr4ParserRULE_list_literal) + p.EnterRule(localctx, 58, YQLParserRULE_list_literal) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1212) - p.Match(YQLv1Antlr4ParserLBRACE_SQUARE) + p.Match(YQLParserLBRACE_SQUARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -10831,10 +10831,10 @@ func (p *YQLv1Antlr4Parser) List_literal() (localctx IList_literalContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1216) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -10844,7 +10844,7 @@ func (p *YQLv1Antlr4Parser) List_literal() (localctx IList_literalContext) { } { p.SetState(1219) - p.Match(YQLv1Antlr4ParserRBRACE_SQUARE) + p.Match(YQLParserRBRACE_SQUARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -10894,13 +10894,13 @@ type Expr_dict_listContext struct { func NewEmptyExpr_dict_listContext() *Expr_dict_listContext { var p = new(Expr_dict_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_dict_list + p.RuleIndex = YQLParserRULE_expr_dict_list return p } func InitEmptyExpr_dict_listContext(p *Expr_dict_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_dict_list + p.RuleIndex = YQLParserRULE_expr_dict_list } func (*Expr_dict_listContext) IsExpr_dict_listContext() {} @@ -10911,7 +10911,7 @@ func NewExpr_dict_listContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_dict_list + p.RuleIndex = YQLParserRULE_expr_dict_list return p } @@ -10960,19 +10960,19 @@ func (s *Expr_dict_listContext) Expr(i int) IExprContext { } func (s *Expr_dict_listContext) AllCOLON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOLON) + return s.GetTokens(YQLParserCOLON) } func (s *Expr_dict_listContext) COLON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLON, i) + return s.GetToken(YQLParserCOLON, i) } func (s *Expr_dict_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Expr_dict_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Expr_dict_listContext) GetRuleContext() antlr.RuleContext { @@ -10985,13 +10985,13 @@ func (s *Expr_dict_listContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Expr_dict_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExpr_dict_list(s) } } func (s *Expr_dict_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExpr_dict_list(s) } } @@ -10999,9 +10999,9 @@ func (s *Expr_dict_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Expr_dict_list() (localctx IExpr_dict_listContext) { +func (p *YQLParser) Expr_dict_list() (localctx IExpr_dict_listContext) { localctx = NewExpr_dict_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 60, YQLv1Antlr4ParserRULE_expr_dict_list) + p.EnterRule(localctx, 60, YQLParserRULE_expr_dict_list) var _la int var _alt int @@ -11019,10 +11019,10 @@ func (p *YQLv1Antlr4Parser) Expr_dict_list() (localctx IExpr_dict_listContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOLON { + if _la == YQLParserCOLON { { p.SetState(1222) - p.Match(YQLv1Antlr4ParserCOLON) + p.Match(YQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11047,7 +11047,7 @@ func (p *YQLv1Antlr4Parser) Expr_dict_list() (localctx IExpr_dict_listContext) { if _alt == 1 { { p.SetState(1226) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11065,10 +11065,10 @@ func (p *YQLv1Antlr4Parser) Expr_dict_list() (localctx IExpr_dict_listContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOLON { + if _la == YQLParserCOLON { { p.SetState(1228) - p.Match(YQLv1Antlr4ParserCOLON) + p.Match(YQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11135,13 +11135,13 @@ type Dict_literalContext struct { func NewEmptyDict_literalContext() *Dict_literalContext { var p = new(Dict_literalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_dict_literal + p.RuleIndex = YQLParserRULE_dict_literal return p } func InitEmptyDict_literalContext(p *Dict_literalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_dict_literal + p.RuleIndex = YQLParserRULE_dict_literal } func (*Dict_literalContext) IsDict_literalContext() {} @@ -11152,7 +11152,7 @@ func NewDict_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_dict_literal + p.RuleIndex = YQLParserRULE_dict_literal return p } @@ -11160,11 +11160,11 @@ func NewDict_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Dict_literalContext) GetParser() antlr.Parser { return s.parser } func (s *Dict_literalContext) LBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_CURLY, 0) + return s.GetToken(YQLParserLBRACE_CURLY, 0) } func (s *Dict_literalContext) RBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_CURLY, 0) + return s.GetToken(YQLParserRBRACE_CURLY, 0) } func (s *Dict_literalContext) Expr_dict_list() IExpr_dict_listContext { @@ -11184,7 +11184,7 @@ func (s *Dict_literalContext) Expr_dict_list() IExpr_dict_listContext { } func (s *Dict_literalContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Dict_literalContext) GetRuleContext() antlr.RuleContext { @@ -11197,13 +11197,13 @@ func (s *Dict_literalContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Dict_literalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDict_literal(s) } } func (s *Dict_literalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDict_literal(s) } } @@ -11211,15 +11211,15 @@ func (s *Dict_literalContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Dict_literal() (localctx IDict_literalContext) { +func (p *YQLParser) Dict_literal() (localctx IDict_literalContext) { localctx = NewDict_literalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 62, YQLv1Antlr4ParserRULE_dict_literal) + p.EnterRule(localctx, 62, YQLParserRULE_dict_literal) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1237) - p.Match(YQLv1Antlr4ParserLBRACE_CURLY) + p.Match(YQLParserLBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11248,10 +11248,10 @@ func (p *YQLv1Antlr4Parser) Dict_literal() (localctx IDict_literalContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1241) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11261,7 +11261,7 @@ func (p *YQLv1Antlr4Parser) Dict_literal() (localctx IDict_literalContext) { } { p.SetState(1244) - p.Match(YQLv1Antlr4ParserRBRACE_CURLY) + p.Match(YQLParserRBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11311,13 +11311,13 @@ type Expr_struct_listContext struct { func NewEmptyExpr_struct_listContext() *Expr_struct_listContext { var p = new(Expr_struct_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_struct_list + p.RuleIndex = YQLParserRULE_expr_struct_list return p } func InitEmptyExpr_struct_listContext(p *Expr_struct_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_struct_list + p.RuleIndex = YQLParserRULE_expr_struct_list } func (*Expr_struct_listContext) IsExpr_struct_listContext() {} @@ -11328,7 +11328,7 @@ func NewExpr_struct_listContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_struct_list + p.RuleIndex = YQLParserRULE_expr_struct_list return p } @@ -11377,19 +11377,19 @@ func (s *Expr_struct_listContext) Expr(i int) IExprContext { } func (s *Expr_struct_listContext) AllCOLON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOLON) + return s.GetTokens(YQLParserCOLON) } func (s *Expr_struct_listContext) COLON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLON, i) + return s.GetToken(YQLParserCOLON, i) } func (s *Expr_struct_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Expr_struct_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Expr_struct_listContext) GetRuleContext() antlr.RuleContext { @@ -11402,13 +11402,13 @@ func (s *Expr_struct_listContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Expr_struct_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExpr_struct_list(s) } } func (s *Expr_struct_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExpr_struct_list(s) } } @@ -11416,9 +11416,9 @@ func (s *Expr_struct_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Expr_struct_list() (localctx IExpr_struct_listContext) { +func (p *YQLParser) Expr_struct_list() (localctx IExpr_struct_listContext) { localctx = NewExpr_struct_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 64, YQLv1Antlr4ParserRULE_expr_struct_list) + p.EnterRule(localctx, 64, YQLParserRULE_expr_struct_list) var _alt int p.EnterOuterAlt(localctx, 1) @@ -11428,7 +11428,7 @@ func (p *YQLv1Antlr4Parser) Expr_struct_list() (localctx IExpr_struct_listContex } { p.SetState(1247) - p.Match(YQLv1Antlr4ParserCOLON) + p.Match(YQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11451,7 +11451,7 @@ func (p *YQLv1Antlr4Parser) Expr_struct_list() (localctx IExpr_struct_listContex if _alt == 1 { { p.SetState(1249) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11463,7 +11463,7 @@ func (p *YQLv1Antlr4Parser) Expr_struct_list() (localctx IExpr_struct_listContex } { p.SetState(1251) - p.Match(YQLv1Antlr4ParserCOLON) + p.Match(YQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11528,13 +11528,13 @@ type Struct_literalContext struct { func NewEmptyStruct_literalContext() *Struct_literalContext { var p = new(Struct_literalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_literal + p.RuleIndex = YQLParserRULE_struct_literal return p } func InitEmptyStruct_literalContext(p *Struct_literalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_literal + p.RuleIndex = YQLParserRULE_struct_literal } func (*Struct_literalContext) IsStruct_literalContext() {} @@ -11545,7 +11545,7 @@ func NewStruct_literalContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_literal + p.RuleIndex = YQLParserRULE_struct_literal return p } @@ -11553,11 +11553,11 @@ func NewStruct_literalContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Struct_literalContext) GetParser() antlr.Parser { return s.parser } func (s *Struct_literalContext) STRUCT_OPEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRUCT_OPEN, 0) + return s.GetToken(YQLParserSTRUCT_OPEN, 0) } func (s *Struct_literalContext) STRUCT_CLOSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRUCT_CLOSE, 0) + return s.GetToken(YQLParserSTRUCT_CLOSE, 0) } func (s *Struct_literalContext) Expr_struct_list() IExpr_struct_listContext { @@ -11577,7 +11577,7 @@ func (s *Struct_literalContext) Expr_struct_list() IExpr_struct_listContext { } func (s *Struct_literalContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Struct_literalContext) GetRuleContext() antlr.RuleContext { @@ -11590,13 +11590,13 @@ func (s *Struct_literalContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Struct_literalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterStruct_literal(s) } } func (s *Struct_literalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitStruct_literal(s) } } @@ -11604,15 +11604,15 @@ func (s *Struct_literalContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Struct_literal() (localctx IStruct_literalContext) { +func (p *YQLParser) Struct_literal() (localctx IStruct_literalContext) { localctx = NewStruct_literalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 66, YQLv1Antlr4ParserRULE_struct_literal) + p.EnterRule(localctx, 66, YQLParserRULE_struct_literal) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1259) - p.Match(YQLv1Antlr4ParserSTRUCT_OPEN) + p.Match(YQLParserSTRUCT_OPEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11641,10 +11641,10 @@ func (p *YQLv1Antlr4Parser) Struct_literal() (localctx IStruct_literalContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1263) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11654,7 +11654,7 @@ func (p *YQLv1Antlr4Parser) Struct_literal() (localctx IStruct_literalContext) { } { p.SetState(1266) - p.Match(YQLv1Antlr4ParserSTRUCT_CLOSE) + p.Match(YQLParserSTRUCT_CLOSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -11713,13 +11713,13 @@ type Atom_exprContext struct { func NewEmptyAtom_exprContext() *Atom_exprContext { var p = new(Atom_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_atom_expr + p.RuleIndex = YQLParserRULE_atom_expr return p } func InitEmptyAtom_exprContext(p *Atom_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_atom_expr + p.RuleIndex = YQLParserRULE_atom_expr } func (*Atom_exprContext) IsAtom_exprContext() {} @@ -11730,7 +11730,7 @@ func NewAtom_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_atom_expr + p.RuleIndex = YQLParserRULE_atom_expr return p } @@ -11850,7 +11850,7 @@ func (s *Atom_exprContext) An_id_or_type() IAn_id_or_typeContext { } func (s *Atom_exprContext) NAMESPACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNAMESPACE, 0) + return s.GetToken(YQLParserNAMESPACE, 0) } func (s *Atom_exprContext) Id_or_type() IId_or_typeContext { @@ -11870,7 +11870,7 @@ func (s *Atom_exprContext) Id_or_type() IId_or_typeContext { } func (s *Atom_exprContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Atom_exprContext) Value_constructor() IValue_constructorContext { @@ -11963,13 +11963,13 @@ func (s *Atom_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Atom_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAtom_expr(s) } } func (s *Atom_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAtom_expr(s) } } @@ -11977,9 +11977,9 @@ func (s *Atom_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Atom_expr() (localctx IAtom_exprContext) { +func (p *YQLParser) Atom_expr() (localctx IAtom_exprContext) { localctx = NewAtom_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 68, YQLv1Antlr4ParserRULE_atom_expr) + p.EnterRule(localctx, 68, YQLParserRULE_atom_expr) p.SetState(1285) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -12043,7 +12043,7 @@ func (p *YQLv1Antlr4Parser) Atom_expr() (localctx IAtom_exprContext) { } { p.SetState(1275) - p.Match(YQLv1Antlr4ParserNAMESPACE) + p.Match(YQLParserNAMESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12056,17 +12056,17 @@ func (p *YQLv1Antlr4Parser) Atom_expr() (localctx IAtom_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(1276) p.Id_or_type() } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: { p.SetState(1277) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12177,13 +12177,13 @@ type In_atom_exprContext struct { func NewEmptyIn_atom_exprContext() *In_atom_exprContext { var p = new(In_atom_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_atom_expr + p.RuleIndex = YQLParserRULE_in_atom_expr return p } func InitEmptyIn_atom_exprContext(p *In_atom_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_atom_expr + p.RuleIndex = YQLParserRULE_in_atom_expr } func (*In_atom_exprContext) IsIn_atom_exprContext() {} @@ -12194,7 +12194,7 @@ func NewIn_atom_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_in_atom_expr + p.RuleIndex = YQLParserRULE_in_atom_expr return p } @@ -12298,7 +12298,7 @@ func (s *In_atom_exprContext) An_id_or_type() IAn_id_or_typeContext { } func (s *In_atom_exprContext) NAMESPACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNAMESPACE, 0) + return s.GetToken(YQLParserNAMESPACE, 0) } func (s *In_atom_exprContext) Id_or_type() IId_or_typeContext { @@ -12318,11 +12318,11 @@ func (s *In_atom_exprContext) Id_or_type() IId_or_typeContext { } func (s *In_atom_exprContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *In_atom_exprContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *In_atom_exprContext) Select_stmt() ISelect_stmtContext { @@ -12342,7 +12342,7 @@ func (s *In_atom_exprContext) Select_stmt() ISelect_stmtContext { } func (s *In_atom_exprContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *In_atom_exprContext) Value_constructor() IValue_constructorContext { @@ -12435,13 +12435,13 @@ func (s *In_atom_exprContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *In_atom_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIn_atom_expr(s) } } func (s *In_atom_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIn_atom_expr(s) } } @@ -12449,9 +12449,9 @@ func (s *In_atom_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) In_atom_expr() (localctx IIn_atom_exprContext) { +func (p *YQLParser) In_atom_expr() (localctx IIn_atom_exprContext) { localctx = NewIn_atom_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 70, YQLv1Antlr4ParserRULE_in_atom_expr) + p.EnterRule(localctx, 70, YQLParserRULE_in_atom_expr) p.SetState(1307) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -12507,7 +12507,7 @@ func (p *YQLv1Antlr4Parser) In_atom_expr() (localctx IIn_atom_exprContext) { } { p.SetState(1293) - p.Match(YQLv1Antlr4ParserNAMESPACE) + p.Match(YQLParserNAMESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12520,17 +12520,17 @@ func (p *YQLv1Antlr4Parser) In_atom_expr() (localctx IIn_atom_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(1294) p.Id_or_type() } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: { p.SetState(1295) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12549,7 +12549,7 @@ func (p *YQLv1Antlr4Parser) In_atom_expr() (localctx IIn_atom_exprContext) { p.EnterOuterAlt(localctx, 7) { p.SetState(1298) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12561,7 +12561,7 @@ func (p *YQLv1Antlr4Parser) In_atom_expr() (localctx IIn_atom_exprContext) { } { p.SetState(1300) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12654,13 +12654,13 @@ type Cast_exprContext struct { func NewEmptyCast_exprContext() *Cast_exprContext { var p = new(Cast_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cast_expr + p.RuleIndex = YQLParserRULE_cast_expr return p } func InitEmptyCast_exprContext(p *Cast_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cast_expr + p.RuleIndex = YQLParserRULE_cast_expr } func (*Cast_exprContext) IsCast_exprContext() {} @@ -12671,7 +12671,7 @@ func NewCast_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_cast_expr + p.RuleIndex = YQLParserRULE_cast_expr return p } @@ -12679,11 +12679,11 @@ func NewCast_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *Cast_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Cast_exprContext) CAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCAST, 0) + return s.GetToken(YQLParserCAST, 0) } func (s *Cast_exprContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Cast_exprContext) Expr() IExprContext { @@ -12703,7 +12703,7 @@ func (s *Cast_exprContext) Expr() IExprContext { } func (s *Cast_exprContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Cast_exprContext) Type_name_or_bind() IType_name_or_bindContext { @@ -12723,7 +12723,7 @@ func (s *Cast_exprContext) Type_name_or_bind() IType_name_or_bindContext { } func (s *Cast_exprContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Cast_exprContext) GetRuleContext() antlr.RuleContext { @@ -12736,13 +12736,13 @@ func (s *Cast_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Cast_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCast_expr(s) } } func (s *Cast_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCast_expr(s) } } @@ -12750,13 +12750,13 @@ func (s *Cast_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Cast_expr() (localctx ICast_exprContext) { +func (p *YQLParser) Cast_expr() (localctx ICast_exprContext) { localctx = NewCast_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 72, YQLv1Antlr4ParserRULE_cast_expr) + p.EnterRule(localctx, 72, YQLParserRULE_cast_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(1309) - p.Match(YQLv1Antlr4ParserCAST) + p.Match(YQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12764,7 +12764,7 @@ func (p *YQLv1Antlr4Parser) Cast_expr() (localctx ICast_exprContext) { } { p.SetState(1310) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12776,7 +12776,7 @@ func (p *YQLv1Antlr4Parser) Cast_expr() (localctx ICast_exprContext) { } { p.SetState(1312) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12788,7 +12788,7 @@ func (p *YQLv1Antlr4Parser) Cast_expr() (localctx ICast_exprContext) { } { p.SetState(1314) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12838,13 +12838,13 @@ type Bitcast_exprContext struct { func NewEmptyBitcast_exprContext() *Bitcast_exprContext { var p = new(Bitcast_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bitcast_expr + p.RuleIndex = YQLParserRULE_bitcast_expr return p } func InitEmptyBitcast_exprContext(p *Bitcast_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bitcast_expr + p.RuleIndex = YQLParserRULE_bitcast_expr } func (*Bitcast_exprContext) IsBitcast_exprContext() {} @@ -12855,7 +12855,7 @@ func NewBitcast_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_bitcast_expr + p.RuleIndex = YQLParserRULE_bitcast_expr return p } @@ -12863,11 +12863,11 @@ func NewBitcast_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Bitcast_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Bitcast_exprContext) BITCAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBITCAST, 0) + return s.GetToken(YQLParserBITCAST, 0) } func (s *Bitcast_exprContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Bitcast_exprContext) Expr() IExprContext { @@ -12887,7 +12887,7 @@ func (s *Bitcast_exprContext) Expr() IExprContext { } func (s *Bitcast_exprContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Bitcast_exprContext) Type_name_simple() IType_name_simpleContext { @@ -12907,7 +12907,7 @@ func (s *Bitcast_exprContext) Type_name_simple() IType_name_simpleContext { } func (s *Bitcast_exprContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Bitcast_exprContext) GetRuleContext() antlr.RuleContext { @@ -12920,13 +12920,13 @@ func (s *Bitcast_exprContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Bitcast_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBitcast_expr(s) } } func (s *Bitcast_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBitcast_expr(s) } } @@ -12934,13 +12934,13 @@ func (s *Bitcast_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Bitcast_expr() (localctx IBitcast_exprContext) { +func (p *YQLParser) Bitcast_expr() (localctx IBitcast_exprContext) { localctx = NewBitcast_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 74, YQLv1Antlr4ParserRULE_bitcast_expr) + p.EnterRule(localctx, 74, YQLParserRULE_bitcast_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(1316) - p.Match(YQLv1Antlr4ParserBITCAST) + p.Match(YQLParserBITCAST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12948,7 +12948,7 @@ func (p *YQLv1Antlr4Parser) Bitcast_expr() (localctx IBitcast_exprContext) { } { p.SetState(1317) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12960,7 +12960,7 @@ func (p *YQLv1Antlr4Parser) Bitcast_expr() (localctx IBitcast_exprContext) { } { p.SetState(1319) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12972,7 +12972,7 @@ func (p *YQLv1Antlr4Parser) Bitcast_expr() (localctx IBitcast_exprContext) { } { p.SetState(1321) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13021,13 +13021,13 @@ type Exists_exprContext struct { func NewEmptyExists_exprContext() *Exists_exprContext { var p = new(Exists_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_exists_expr + p.RuleIndex = YQLParserRULE_exists_expr return p } func InitEmptyExists_exprContext(p *Exists_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_exists_expr + p.RuleIndex = YQLParserRULE_exists_expr } func (*Exists_exprContext) IsExists_exprContext() {} @@ -13038,7 +13038,7 @@ func NewExists_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_exists_expr + p.RuleIndex = YQLParserRULE_exists_expr return p } @@ -13046,15 +13046,15 @@ func NewExists_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Exists_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Exists_exprContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Exists_exprContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Exists_exprContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Exists_exprContext) Select_stmt() ISelect_stmtContext { @@ -13099,13 +13099,13 @@ func (s *Exists_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Exists_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExists_expr(s) } } func (s *Exists_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExists_expr(s) } } @@ -13113,13 +13113,13 @@ func (s *Exists_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Exists_expr() (localctx IExists_exprContext) { +func (p *YQLParser) Exists_expr() (localctx IExists_exprContext) { localctx = NewExists_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 76, YQLv1Antlr4ParserRULE_exists_expr) + p.EnterRule(localctx, 76, YQLParserRULE_exists_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(1323) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13127,7 +13127,7 @@ func (p *YQLv1Antlr4Parser) Exists_expr() (localctx IExists_exprContext) { } { p.SetState(1324) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13140,14 +13140,14 @@ func (p *YQLv1Antlr4Parser) Exists_expr() (localctx IExists_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLPAREN, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserSELECT: + case YQLParserLPAREN, YQLParserDISCARD, YQLParserFROM, YQLParserPROCESS, YQLParserREDUCE, YQLParserSELECT: { p.SetState(1325) p.Select_stmt() } - case YQLv1Antlr4ParserVALUES: + case YQLParserVALUES: { p.SetState(1326) p.Values_stmt() @@ -13161,7 +13161,7 @@ func (p *YQLv1Antlr4Parser) Exists_expr() (localctx IExists_exprContext) { } { p.SetState(1329) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13212,13 +13212,13 @@ type Case_exprContext struct { func NewEmptyCase_exprContext() *Case_exprContext { var p = new(Case_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_case_expr + p.RuleIndex = YQLParserRULE_case_expr return p } func InitEmptyCase_exprContext(p *Case_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_case_expr + p.RuleIndex = YQLParserRULE_case_expr } func (*Case_exprContext) IsCase_exprContext() {} @@ -13229,7 +13229,7 @@ func NewCase_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_case_expr + p.RuleIndex = YQLParserRULE_case_expr return p } @@ -13237,11 +13237,11 @@ func NewCase_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *Case_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Case_exprContext) CASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCASE, 0) + return s.GetToken(YQLParserCASE, 0) } func (s *Case_exprContext) END() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEND, 0) + return s.GetToken(YQLParserEND, 0) } func (s *Case_exprContext) AllExpr() []IExprContext { @@ -13327,7 +13327,7 @@ func (s *Case_exprContext) When_expr(i int) IWhen_exprContext { } func (s *Case_exprContext) ELSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserELSE, 0) + return s.GetToken(YQLParserELSE, 0) } func (s *Case_exprContext) GetRuleContext() antlr.RuleContext { @@ -13340,13 +13340,13 @@ func (s *Case_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Case_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCase_expr(s) } } func (s *Case_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCase_expr(s) } } @@ -13354,15 +13354,15 @@ func (s *Case_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Case_expr() (localctx ICase_exprContext) { +func (p *YQLParser) Case_expr() (localctx ICase_exprContext) { localctx = NewCase_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 78, YQLv1Antlr4ParserRULE_case_expr) + p.EnterRule(localctx, 78, YQLParserRULE_case_expr) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1331) - p.Match(YQLv1Antlr4ParserCASE) + p.Match(YQLParserCASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13389,7 +13389,7 @@ func (p *YQLv1Antlr4Parser) Case_expr() (localctx ICase_exprContext) { _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == YQLv1Antlr4ParserWHEN { + for ok := true; ok; ok = _la == YQLParserWHEN { { p.SetState(1335) p.When_expr() @@ -13411,10 +13411,10 @@ func (p *YQLv1Antlr4Parser) Case_expr() (localctx ICase_exprContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserELSE { + if _la == YQLParserELSE { { p.SetState(1340) - p.Match(YQLv1Antlr4ParserELSE) + p.Match(YQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13428,7 +13428,7 @@ func (p *YQLv1Antlr4Parser) Case_expr() (localctx ICase_exprContext) { } { p.SetState(1344) - p.Match(YQLv1Antlr4ParserEND) + p.Match(YQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13480,13 +13480,13 @@ type LambdaContext struct { func NewEmptyLambdaContext() *LambdaContext { var p = new(LambdaContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda + p.RuleIndex = YQLParserRULE_lambda return p } func InitEmptyLambdaContext(p *LambdaContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda + p.RuleIndex = YQLParserRULE_lambda } func (*LambdaContext) IsLambdaContext() {} @@ -13497,7 +13497,7 @@ func NewLambdaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invok antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_lambda + p.RuleIndex = YQLParserRULE_lambda return p } @@ -13521,11 +13521,11 @@ func (s *LambdaContext) Smart_parenthesis() ISmart_parenthesisContext { } func (s *LambdaContext) ARROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserARROW, 0) + return s.GetToken(YQLParserARROW, 0) } func (s *LambdaContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *LambdaContext) Expr() IExprContext { @@ -13545,11 +13545,11 @@ func (s *LambdaContext) Expr() IExprContext { } func (s *LambdaContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *LambdaContext) LBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_CURLY, 0) + return s.GetToken(YQLParserLBRACE_CURLY, 0) } func (s *LambdaContext) Lambda_body() ILambda_bodyContext { @@ -13569,7 +13569,7 @@ func (s *LambdaContext) Lambda_body() ILambda_bodyContext { } func (s *LambdaContext) RBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_CURLY, 0) + return s.GetToken(YQLParserRBRACE_CURLY, 0) } func (s *LambdaContext) GetRuleContext() antlr.RuleContext { @@ -13582,13 +13582,13 @@ func (s *LambdaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) func (s *LambdaContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterLambda(s) } } func (s *LambdaContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitLambda(s) } } @@ -13596,9 +13596,9 @@ func (s *LambdaContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Lambda() (localctx ILambdaContext) { +func (p *YQLParser) Lambda() (localctx ILambdaContext) { localctx = NewLambdaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 80, YQLv1Antlr4ParserRULE_lambda) + p.EnterRule(localctx, 80, YQLParserRULE_lambda) var _la int p.EnterOuterAlt(localctx, 1) @@ -13614,10 +13614,10 @@ func (p *YQLv1Antlr4Parser) Lambda() (localctx ILambdaContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserARROW { + if _la == YQLParserARROW { { p.SetState(1347) - p.Match(YQLv1Antlr4ParserARROW) + p.Match(YQLParserARROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13630,10 +13630,10 @@ func (p *YQLv1Antlr4Parser) Lambda() (localctx ILambdaContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: { p.SetState(1348) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13645,7 +13645,7 @@ func (p *YQLv1Antlr4Parser) Lambda() (localctx ILambdaContext) { } { p.SetState(1350) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13653,10 +13653,10 @@ func (p *YQLv1Antlr4Parser) Lambda() (localctx ILambdaContext) { } - case YQLv1Antlr4ParserLBRACE_CURLY: + case YQLParserLBRACE_CURLY: { p.SetState(1352) - p.Match(YQLv1Antlr4ParserLBRACE_CURLY) + p.Match(YQLParserLBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13668,7 +13668,7 @@ func (p *YQLv1Antlr4Parser) Lambda() (localctx ILambdaContext) { } { p.SetState(1354) - p.Match(YQLv1Antlr4ParserRBRACE_CURLY) + p.Match(YQLParserRBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13722,13 +13722,13 @@ type In_exprContext struct { func NewEmptyIn_exprContext() *In_exprContext { var p = new(In_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_expr + p.RuleIndex = YQLParserRULE_in_expr return p } func InitEmptyIn_exprContext(p *In_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_in_expr + p.RuleIndex = YQLParserRULE_in_expr } func (*In_exprContext) IsIn_exprContext() {} @@ -13739,7 +13739,7 @@ func NewIn_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_in_expr + p.RuleIndex = YQLParserRULE_in_expr return p } @@ -13772,13 +13772,13 @@ func (s *In_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *In_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIn_expr(s) } } func (s *In_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIn_expr(s) } } @@ -13786,9 +13786,9 @@ func (s *In_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) In_expr() (localctx IIn_exprContext) { +func (p *YQLParser) In_expr() (localctx IIn_exprContext) { localctx = NewIn_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 82, YQLv1Antlr4ParserRULE_in_expr) + p.EnterRule(localctx, 82, YQLParserRULE_in_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(1360) @@ -13835,13 +13835,13 @@ type Json_api_exprContext struct { func NewEmptyJson_api_exprContext() *Json_api_exprContext { var p = new(Json_api_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_api_expr + p.RuleIndex = YQLParserRULE_json_api_expr return p } func InitEmptyJson_api_exprContext(p *Json_api_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_api_expr + p.RuleIndex = YQLParserRULE_json_api_expr } func (*Json_api_exprContext) IsJson_api_exprContext() {} @@ -13852,7 +13852,7 @@ func NewJson_api_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_api_expr + p.RuleIndex = YQLParserRULE_json_api_expr return p } @@ -13917,13 +13917,13 @@ func (s *Json_api_exprContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Json_api_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_api_expr(s) } } func (s *Json_api_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_api_expr(s) } } @@ -13931,9 +13931,9 @@ func (s *Json_api_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_api_expr() (localctx IJson_api_exprContext) { +func (p *YQLParser) Json_api_expr() (localctx IJson_api_exprContext) { localctx = NewJson_api_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 84, YQLv1Antlr4ParserRULE_json_api_expr) + p.EnterRule(localctx, 84, YQLParserRULE_json_api_expr) p.SetState(1365) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -13941,7 +13941,7 @@ func (p *YQLv1Antlr4Parser) Json_api_expr() (localctx IJson_api_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserJSON_VALUE: + case YQLParserJSON_VALUE: p.EnterOuterAlt(localctx, 1) { p.SetState(1362) @@ -13949,7 +13949,7 @@ func (p *YQLv1Antlr4Parser) Json_api_expr() (localctx IJson_api_exprContext) { } - case YQLv1Antlr4ParserJSON_EXISTS: + case YQLParserJSON_EXISTS: p.EnterOuterAlt(localctx, 2) { p.SetState(1363) @@ -13957,7 +13957,7 @@ func (p *YQLv1Antlr4Parser) Json_api_expr() (localctx IJson_api_exprContext) { } - case YQLv1Antlr4ParserJSON_QUERY: + case YQLParserJSON_QUERY: p.EnterOuterAlt(localctx, 3) { p.SetState(1364) @@ -14008,13 +14008,13 @@ type Jsonpath_specContext struct { func NewEmptyJsonpath_specContext() *Jsonpath_specContext { var p = new(Jsonpath_specContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_jsonpath_spec + p.RuleIndex = YQLParserRULE_jsonpath_spec return p } func InitEmptyJsonpath_specContext(p *Jsonpath_specContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_jsonpath_spec + p.RuleIndex = YQLParserRULE_jsonpath_spec } func (*Jsonpath_specContext) IsJsonpath_specContext() {} @@ -14025,7 +14025,7 @@ func NewJsonpath_specContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_jsonpath_spec + p.RuleIndex = YQLParserRULE_jsonpath_spec return p } @@ -14033,7 +14033,7 @@ func NewJsonpath_specContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Jsonpath_specContext) GetParser() antlr.Parser { return s.parser } func (s *Jsonpath_specContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Jsonpath_specContext) GetRuleContext() antlr.RuleContext { @@ -14046,13 +14046,13 @@ func (s *Jsonpath_specContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Jsonpath_specContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJsonpath_spec(s) } } func (s *Jsonpath_specContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJsonpath_spec(s) } } @@ -14060,13 +14060,13 @@ func (s *Jsonpath_specContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Jsonpath_spec() (localctx IJsonpath_specContext) { +func (p *YQLParser) Jsonpath_spec() (localctx IJsonpath_specContext) { localctx = NewJsonpath_specContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 86, YQLv1Antlr4ParserRULE_jsonpath_spec) + p.EnterRule(localctx, 86, YQLParserRULE_jsonpath_spec) p.EnterOuterAlt(localctx, 1) { p.SetState(1367) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14112,13 +14112,13 @@ type Json_variable_nameContext struct { func NewEmptyJson_variable_nameContext() *Json_variable_nameContext { var p = new(Json_variable_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variable_name + p.RuleIndex = YQLParserRULE_json_variable_name return p } func InitEmptyJson_variable_nameContext(p *Json_variable_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variable_name + p.RuleIndex = YQLParserRULE_json_variable_name } func (*Json_variable_nameContext) IsJson_variable_nameContext() {} @@ -14129,7 +14129,7 @@ func NewJson_variable_nameContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variable_name + p.RuleIndex = YQLParserRULE_json_variable_name return p } @@ -14153,7 +14153,7 @@ func (s *Json_variable_nameContext) Id_expr() IId_exprContext { } func (s *Json_variable_nameContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Json_variable_nameContext) GetRuleContext() antlr.RuleContext { @@ -14166,13 +14166,13 @@ func (s *Json_variable_nameContext) ToStringTree(ruleNames []string, recog antlr func (s *Json_variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_variable_name(s) } } func (s *Json_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_variable_name(s) } } @@ -14180,9 +14180,9 @@ func (s *Json_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_variable_name() (localctx IJson_variable_nameContext) { +func (p *YQLParser) Json_variable_name() (localctx IJson_variable_nameContext) { localctx = NewJson_variable_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 88, YQLv1Antlr4ParserRULE_json_variable_name) + p.EnterRule(localctx, 88, YQLParserRULE_json_variable_name) p.SetState(1371) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -14190,7 +14190,7 @@ func (p *YQLv1Antlr4Parser) Json_variable_name() (localctx IJson_variable_nameCo } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(1369) @@ -14198,11 +14198,11 @@ func (p *YQLv1Antlr4Parser) Json_variable_name() (localctx IJson_variable_nameCo } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(1370) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14255,13 +14255,13 @@ type Json_variableContext struct { func NewEmptyJson_variableContext() *Json_variableContext { var p = new(Json_variableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variable + p.RuleIndex = YQLParserRULE_json_variable return p } func InitEmptyJson_variableContext(p *Json_variableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variable + p.RuleIndex = YQLParserRULE_json_variable } func (*Json_variableContext) IsJson_variableContext() {} @@ -14272,7 +14272,7 @@ func NewJson_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variable + p.RuleIndex = YQLParserRULE_json_variable return p } @@ -14296,7 +14296,7 @@ func (s *Json_variableContext) Expr() IExprContext { } func (s *Json_variableContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Json_variableContext) Json_variable_name() IJson_variable_nameContext { @@ -14325,13 +14325,13 @@ func (s *Json_variableContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Json_variableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_variable(s) } } func (s *Json_variableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_variable(s) } } @@ -14339,9 +14339,9 @@ func (s *Json_variableContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_variable() (localctx IJson_variableContext) { +func (p *YQLParser) Json_variable() (localctx IJson_variableContext) { localctx = NewJson_variableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 90, YQLv1Antlr4ParserRULE_json_variable) + p.EnterRule(localctx, 90, YQLParserRULE_json_variable) p.EnterOuterAlt(localctx, 1) { p.SetState(1373) @@ -14349,7 +14349,7 @@ func (p *YQLv1Antlr4Parser) Json_variable() (localctx IJson_variableContext) { } { p.SetState(1374) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14401,13 +14401,13 @@ type Json_variablesContext struct { func NewEmptyJson_variablesContext() *Json_variablesContext { var p = new(Json_variablesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variables + p.RuleIndex = YQLParserRULE_json_variables return p } func InitEmptyJson_variablesContext(p *Json_variablesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variables + p.RuleIndex = YQLParserRULE_json_variables } func (*Json_variablesContext) IsJson_variablesContext() {} @@ -14418,7 +14418,7 @@ func NewJson_variablesContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_variables + p.RuleIndex = YQLParserRULE_json_variables return p } @@ -14467,11 +14467,11 @@ func (s *Json_variablesContext) Json_variable(i int) IJson_variableContext { } func (s *Json_variablesContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Json_variablesContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Json_variablesContext) GetRuleContext() antlr.RuleContext { @@ -14484,13 +14484,13 @@ func (s *Json_variablesContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Json_variablesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_variables(s) } } func (s *Json_variablesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_variables(s) } } @@ -14498,9 +14498,9 @@ func (s *Json_variablesContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_variables() (localctx IJson_variablesContext) { +func (p *YQLParser) Json_variables() (localctx IJson_variablesContext) { localctx = NewJson_variablesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 92, YQLv1Antlr4ParserRULE_json_variables) + p.EnterRule(localctx, 92, YQLParserRULE_json_variables) var _la int p.EnterOuterAlt(localctx, 1) @@ -14516,10 +14516,10 @@ func (p *YQLv1Antlr4Parser) Json_variables() (localctx IJson_variablesContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(1378) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14581,13 +14581,13 @@ type Json_common_argsContext struct { func NewEmptyJson_common_argsContext() *Json_common_argsContext { var p = new(Json_common_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_common_args + p.RuleIndex = YQLParserRULE_json_common_args return p } func InitEmptyJson_common_argsContext(p *Json_common_argsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_common_args + p.RuleIndex = YQLParserRULE_json_common_args } func (*Json_common_argsContext) IsJson_common_argsContext() {} @@ -14598,7 +14598,7 @@ func NewJson_common_argsContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_common_args + p.RuleIndex = YQLParserRULE_json_common_args return p } @@ -14622,7 +14622,7 @@ func (s *Json_common_argsContext) Expr() IExprContext { } func (s *Json_common_argsContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Json_common_argsContext) Jsonpath_spec() IJsonpath_specContext { @@ -14642,7 +14642,7 @@ func (s *Json_common_argsContext) Jsonpath_spec() IJsonpath_specContext { } func (s *Json_common_argsContext) PASSING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPASSING, 0) + return s.GetToken(YQLParserPASSING, 0) } func (s *Json_common_argsContext) Json_variables() IJson_variablesContext { @@ -14671,13 +14671,13 @@ func (s *Json_common_argsContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Json_common_argsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_common_args(s) } } func (s *Json_common_argsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_common_args(s) } } @@ -14685,9 +14685,9 @@ func (s *Json_common_argsContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_common_args() (localctx IJson_common_argsContext) { +func (p *YQLParser) Json_common_args() (localctx IJson_common_argsContext) { localctx = NewJson_common_argsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 94, YQLv1Antlr4ParserRULE_json_common_args) + p.EnterRule(localctx, 94, YQLParserRULE_json_common_args) var _la int p.EnterOuterAlt(localctx, 1) @@ -14697,7 +14697,7 @@ func (p *YQLv1Antlr4Parser) Json_common_args() (localctx IJson_common_argsContex } { p.SetState(1386) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14715,10 +14715,10 @@ func (p *YQLv1Antlr4Parser) Json_common_args() (localctx IJson_common_argsContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPASSING { + if _la == YQLParserPASSING { { p.SetState(1388) - p.Match(YQLv1Antlr4ParserPASSING) + p.Match(YQLParserPASSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14772,13 +14772,13 @@ type Json_case_handlerContext struct { func NewEmptyJson_case_handlerContext() *Json_case_handlerContext { var p = new(Json_case_handlerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_case_handler + p.RuleIndex = YQLParserRULE_json_case_handler return p } func InitEmptyJson_case_handlerContext(p *Json_case_handlerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_case_handler + p.RuleIndex = YQLParserRULE_json_case_handler } func (*Json_case_handlerContext) IsJson_case_handlerContext() {} @@ -14789,7 +14789,7 @@ func NewJson_case_handlerContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_case_handler + p.RuleIndex = YQLParserRULE_json_case_handler return p } @@ -14797,15 +14797,15 @@ func NewJson_case_handlerContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Json_case_handlerContext) GetParser() antlr.Parser { return s.parser } func (s *Json_case_handlerContext) ERROR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERROR, 0) + return s.GetToken(YQLParserERROR, 0) } func (s *Json_case_handlerContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Json_case_handlerContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFAULT, 0) + return s.GetToken(YQLParserDEFAULT, 0) } func (s *Json_case_handlerContext) Expr() IExprContext { @@ -14834,13 +14834,13 @@ func (s *Json_case_handlerContext) ToStringTree(ruleNames []string, recog antlr. func (s *Json_case_handlerContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_case_handler(s) } } func (s *Json_case_handlerContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_case_handler(s) } } @@ -14848,9 +14848,9 @@ func (s *Json_case_handlerContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_case_handler() (localctx IJson_case_handlerContext) { +func (p *YQLParser) Json_case_handler() (localctx IJson_case_handlerContext) { localctx = NewJson_case_handlerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 96, YQLv1Antlr4ParserRULE_json_case_handler) + p.EnterRule(localctx, 96, YQLParserRULE_json_case_handler) p.SetState(1396) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -14858,11 +14858,11 @@ func (p *YQLv1Antlr4Parser) Json_case_handler() (localctx IJson_case_handlerCont } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserERROR: + case YQLParserERROR: p.EnterOuterAlt(localctx, 1) { p.SetState(1392) - p.Match(YQLv1Antlr4ParserERROR) + p.Match(YQLParserERROR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14870,11 +14870,11 @@ func (p *YQLv1Antlr4Parser) Json_case_handler() (localctx IJson_case_handlerCont } - case YQLv1Antlr4ParserNULL: + case YQLParserNULL: p.EnterOuterAlt(localctx, 2) { p.SetState(1393) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14882,11 +14882,11 @@ func (p *YQLv1Antlr4Parser) Json_case_handler() (localctx IJson_case_handlerCont } - case YQLv1Antlr4ParserDEFAULT: + case YQLParserDEFAULT: p.EnterOuterAlt(localctx, 3) { p.SetState(1394) - p.Match(YQLv1Antlr4ParserDEFAULT) + p.Match(YQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14954,13 +14954,13 @@ type Json_valueContext struct { func NewEmptyJson_valueContext() *Json_valueContext { var p = new(Json_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_value + p.RuleIndex = YQLParserRULE_json_value return p } func InitEmptyJson_valueContext(p *Json_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_value + p.RuleIndex = YQLParserRULE_json_value } func (*Json_valueContext) IsJson_valueContext() {} @@ -14971,7 +14971,7 @@ func NewJson_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_value + p.RuleIndex = YQLParserRULE_json_value return p } @@ -14979,11 +14979,11 @@ func NewJson_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *Json_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Json_valueContext) JSON_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJSON_VALUE, 0) + return s.GetToken(YQLParserJSON_VALUE, 0) } func (s *Json_valueContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Json_valueContext) Json_common_args() IJson_common_argsContext { @@ -15003,11 +15003,11 @@ func (s *Json_valueContext) Json_common_args() IJson_common_argsContext { } func (s *Json_valueContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Json_valueContext) RETURNING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRETURNING, 0) + return s.GetToken(YQLParserRETURNING, 0) } func (s *Json_valueContext) Type_name_simple() IType_name_simpleContext { @@ -15068,27 +15068,27 @@ func (s *Json_valueContext) Json_case_handler(i int) IJson_case_handlerContext { } func (s *Json_valueContext) AllON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserON) + return s.GetTokens(YQLParserON) } func (s *Json_valueContext) ON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, i) + return s.GetToken(YQLParserON, i) } func (s *Json_valueContext) AllEMPTY() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserEMPTY) + return s.GetTokens(YQLParserEMPTY) } func (s *Json_valueContext) EMPTY(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY, i) + return s.GetToken(YQLParserEMPTY, i) } func (s *Json_valueContext) AllERROR() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserERROR) + return s.GetTokens(YQLParserERROR) } func (s *Json_valueContext) ERROR(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERROR, i) + return s.GetToken(YQLParserERROR, i) } func (s *Json_valueContext) GetRuleContext() antlr.RuleContext { @@ -15101,13 +15101,13 @@ func (s *Json_valueContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Json_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_value(s) } } func (s *Json_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_value(s) } } @@ -15115,15 +15115,15 @@ func (s *Json_valueContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_value() (localctx IJson_valueContext) { +func (p *YQLParser) Json_value() (localctx IJson_valueContext) { localctx = NewJson_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 98, YQLv1Antlr4ParserRULE_json_value) + p.EnterRule(localctx, 98, YQLParserRULE_json_value) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1398) - p.Match(YQLv1Antlr4ParserJSON_VALUE) + p.Match(YQLParserJSON_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15131,7 +15131,7 @@ func (p *YQLv1Antlr4Parser) Json_value() (localctx IJson_valueContext) { } { p.SetState(1399) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15149,10 +15149,10 @@ func (p *YQLv1Antlr4Parser) Json_value() (localctx IJson_valueContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserRETURNING { + if _la == YQLParserRETURNING { { p.SetState(1401) - p.Match(YQLv1Antlr4ParserRETURNING) + p.Match(YQLParserRETURNING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15172,14 +15172,14 @@ func (p *YQLv1Antlr4Parser) Json_value() (localctx IJson_valueContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserDEFAULT || _la == YQLv1Antlr4ParserERROR || _la == YQLv1Antlr4ParserNULL { + for _la == YQLParserDEFAULT || _la == YQLParserERROR || _la == YQLParserNULL { { p.SetState(1405) p.Json_case_handler() } { p.SetState(1406) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15189,7 +15189,7 @@ func (p *YQLv1Antlr4Parser) Json_value() (localctx IJson_valueContext) { p.SetState(1407) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserEMPTY || _la == YQLv1Antlr4ParserERROR) { + if !(_la == YQLParserEMPTY || _la == YQLParserERROR) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -15207,7 +15207,7 @@ func (p *YQLv1Antlr4Parser) Json_value() (localctx IJson_valueContext) { } { p.SetState(1414) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15257,13 +15257,13 @@ type Json_exists_handlerContext struct { func NewEmptyJson_exists_handlerContext() *Json_exists_handlerContext { var p = new(Json_exists_handlerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_exists_handler + p.RuleIndex = YQLParserRULE_json_exists_handler return p } func InitEmptyJson_exists_handlerContext(p *Json_exists_handlerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_exists_handler + p.RuleIndex = YQLParserRULE_json_exists_handler } func (*Json_exists_handlerContext) IsJson_exists_handlerContext() {} @@ -15274,7 +15274,7 @@ func NewJson_exists_handlerContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_exists_handler + p.RuleIndex = YQLParserRULE_json_exists_handler return p } @@ -15282,27 +15282,27 @@ func NewJson_exists_handlerContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *Json_exists_handlerContext) GetParser() antlr.Parser { return s.parser } func (s *Json_exists_handlerContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Json_exists_handlerContext) AllERROR() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserERROR) + return s.GetTokens(YQLParserERROR) } func (s *Json_exists_handlerContext) ERROR(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERROR, i) + return s.GetToken(YQLParserERROR, i) } func (s *Json_exists_handlerContext) TRUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTRUE, 0) + return s.GetToken(YQLParserTRUE, 0) } func (s *Json_exists_handlerContext) FALSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFALSE, 0) + return s.GetToken(YQLParserFALSE, 0) } func (s *Json_exists_handlerContext) UNKNOWN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNKNOWN, 0) + return s.GetToken(YQLParserUNKNOWN, 0) } func (s *Json_exists_handlerContext) GetRuleContext() antlr.RuleContext { @@ -15315,13 +15315,13 @@ func (s *Json_exists_handlerContext) ToStringTree(ruleNames []string, recog antl func (s *Json_exists_handlerContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_exists_handler(s) } } func (s *Json_exists_handlerContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_exists_handler(s) } } @@ -15329,9 +15329,9 @@ func (s *Json_exists_handlerContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Json_exists_handler() (localctx IJson_exists_handlerContext) { +func (p *YQLParser) Json_exists_handler() (localctx IJson_exists_handlerContext) { localctx = NewJson_exists_handlerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 100, YQLv1Antlr4ParserRULE_json_exists_handler) + p.EnterRule(localctx, 100, YQLParserRULE_json_exists_handler) var _la int p.EnterOuterAlt(localctx, 1) @@ -15339,7 +15339,7 @@ func (p *YQLv1Antlr4Parser) Json_exists_handler() (localctx IJson_exists_handler p.SetState(1416) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserERROR || _la == YQLv1Antlr4ParserFALSE || _la == YQLv1Antlr4ParserTRUE || _la == YQLv1Antlr4ParserUNKNOWN) { + if !(_la == YQLParserERROR || _la == YQLParserFALSE || _la == YQLParserTRUE || _la == YQLParserUNKNOWN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -15348,7 +15348,7 @@ func (p *YQLv1Antlr4Parser) Json_exists_handler() (localctx IJson_exists_handler } { p.SetState(1417) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15356,7 +15356,7 @@ func (p *YQLv1Antlr4Parser) Json_exists_handler() (localctx IJson_exists_handler } { p.SetState(1418) - p.Match(YQLv1Antlr4ParserERROR) + p.Match(YQLParserERROR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15405,13 +15405,13 @@ type Json_existsContext struct { func NewEmptyJson_existsContext() *Json_existsContext { var p = new(Json_existsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_exists + p.RuleIndex = YQLParserRULE_json_exists return p } func InitEmptyJson_existsContext(p *Json_existsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_exists + p.RuleIndex = YQLParserRULE_json_exists } func (*Json_existsContext) IsJson_existsContext() {} @@ -15422,7 +15422,7 @@ func NewJson_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_exists + p.RuleIndex = YQLParserRULE_json_exists return p } @@ -15430,11 +15430,11 @@ func NewJson_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Json_existsContext) GetParser() antlr.Parser { return s.parser } func (s *Json_existsContext) JSON_EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJSON_EXISTS, 0) + return s.GetToken(YQLParserJSON_EXISTS, 0) } func (s *Json_existsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Json_existsContext) Json_common_args() IJson_common_argsContext { @@ -15454,7 +15454,7 @@ func (s *Json_existsContext) Json_common_args() IJson_common_argsContext { } func (s *Json_existsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Json_existsContext) Json_exists_handler() IJson_exists_handlerContext { @@ -15483,13 +15483,13 @@ func (s *Json_existsContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Json_existsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_exists(s) } } func (s *Json_existsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_exists(s) } } @@ -15497,15 +15497,15 @@ func (s *Json_existsContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_exists() (localctx IJson_existsContext) { +func (p *YQLParser) Json_exists() (localctx IJson_existsContext) { localctx = NewJson_existsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 102, YQLv1Antlr4ParserRULE_json_exists) + p.EnterRule(localctx, 102, YQLParserRULE_json_exists) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1420) - p.Match(YQLv1Antlr4ParserJSON_EXISTS) + p.Match(YQLParserJSON_EXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15513,7 +15513,7 @@ func (p *YQLv1Antlr4Parser) Json_exists() (localctx IJson_existsContext) { } { p.SetState(1421) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15531,7 +15531,7 @@ func (p *YQLv1Antlr4Parser) Json_exists() (localctx IJson_existsContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserERROR || _la == YQLv1Antlr4ParserFALSE || _la == YQLv1Antlr4ParserTRUE || _la == YQLv1Antlr4ParserUNKNOWN { + if _la == YQLParserERROR || _la == YQLParserFALSE || _la == YQLParserTRUE || _la == YQLParserUNKNOWN { { p.SetState(1423) p.Json_exists_handler() @@ -15540,7 +15540,7 @@ func (p *YQLv1Antlr4Parser) Json_exists() (localctx IJson_existsContext) { } { p.SetState(1426) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15589,13 +15589,13 @@ type Json_query_wrapperContext struct { func NewEmptyJson_query_wrapperContext() *Json_query_wrapperContext { var p = new(Json_query_wrapperContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query_wrapper + p.RuleIndex = YQLParserRULE_json_query_wrapper return p } func InitEmptyJson_query_wrapperContext(p *Json_query_wrapperContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query_wrapper + p.RuleIndex = YQLParserRULE_json_query_wrapper } func (*Json_query_wrapperContext) IsJson_query_wrapperContext() {} @@ -15606,7 +15606,7 @@ func NewJson_query_wrapperContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query_wrapper + p.RuleIndex = YQLParserRULE_json_query_wrapper return p } @@ -15614,23 +15614,23 @@ func NewJson_query_wrapperContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Json_query_wrapperContext) GetParser() antlr.Parser { return s.parser } func (s *Json_query_wrapperContext) WITHOUT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITHOUT, 0) + return s.GetToken(YQLParserWITHOUT, 0) } func (s *Json_query_wrapperContext) ARRAY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserARRAY, 0) + return s.GetToken(YQLParserARRAY, 0) } func (s *Json_query_wrapperContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Json_query_wrapperContext) CONDITIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONDITIONAL, 0) + return s.GetToken(YQLParserCONDITIONAL, 0) } func (s *Json_query_wrapperContext) UNCONDITIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNCONDITIONAL, 0) + return s.GetToken(YQLParserUNCONDITIONAL, 0) } func (s *Json_query_wrapperContext) GetRuleContext() antlr.RuleContext { @@ -15643,13 +15643,13 @@ func (s *Json_query_wrapperContext) ToStringTree(ruleNames []string, recog antlr func (s *Json_query_wrapperContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_query_wrapper(s) } } func (s *Json_query_wrapperContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_query_wrapper(s) } } @@ -15657,9 +15657,9 @@ func (s *Json_query_wrapperContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_query_wrapper() (localctx IJson_query_wrapperContext) { +func (p *YQLParser) Json_query_wrapper() (localctx IJson_query_wrapperContext) { localctx = NewJson_query_wrapperContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 104, YQLv1Antlr4ParserRULE_json_query_wrapper) + p.EnterRule(localctx, 104, YQLParserRULE_json_query_wrapper) var _la int p.SetState(1439) @@ -15669,11 +15669,11 @@ func (p *YQLv1Antlr4Parser) Json_query_wrapper() (localctx IJson_query_wrapperCo } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserWITHOUT: + case YQLParserWITHOUT: p.EnterOuterAlt(localctx, 1) { p.SetState(1428) - p.Match(YQLv1Antlr4ParserWITHOUT) + p.Match(YQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15687,10 +15687,10 @@ func (p *YQLv1Antlr4Parser) Json_query_wrapper() (localctx IJson_query_wrapperCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserARRAY { + if _la == YQLParserARRAY { { p.SetState(1429) - p.Match(YQLv1Antlr4ParserARRAY) + p.Match(YQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15700,11 +15700,11 @@ func (p *YQLv1Antlr4Parser) Json_query_wrapper() (localctx IJson_query_wrapperCo } - case YQLv1Antlr4ParserWITH: + case YQLParserWITH: p.EnterOuterAlt(localctx, 2) { p.SetState(1432) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15718,12 +15718,12 @@ func (p *YQLv1Antlr4Parser) Json_query_wrapper() (localctx IJson_query_wrapperCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCONDITIONAL || _la == YQLv1Antlr4ParserUNCONDITIONAL { + if _la == YQLParserCONDITIONAL || _la == YQLParserUNCONDITIONAL { { p.SetState(1433) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserCONDITIONAL || _la == YQLv1Antlr4ParserUNCONDITIONAL) { + if !(_la == YQLParserCONDITIONAL || _la == YQLParserUNCONDITIONAL) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -15740,10 +15740,10 @@ func (p *YQLv1Antlr4Parser) Json_query_wrapper() (localctx IJson_query_wrapperCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserARRAY { + if _la == YQLParserARRAY { { p.SetState(1436) - p.Match(YQLv1Antlr4ParserARRAY) + p.Match(YQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15800,13 +15800,13 @@ type Json_query_handlerContext struct { func NewEmptyJson_query_handlerContext() *Json_query_handlerContext { var p = new(Json_query_handlerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query_handler + p.RuleIndex = YQLParserRULE_json_query_handler return p } func InitEmptyJson_query_handlerContext(p *Json_query_handlerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query_handler + p.RuleIndex = YQLParserRULE_json_query_handler } func (*Json_query_handlerContext) IsJson_query_handlerContext() {} @@ -15817,7 +15817,7 @@ func NewJson_query_handlerContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query_handler + p.RuleIndex = YQLParserRULE_json_query_handler return p } @@ -15825,23 +15825,23 @@ func NewJson_query_handlerContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Json_query_handlerContext) GetParser() antlr.Parser { return s.parser } func (s *Json_query_handlerContext) ERROR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERROR, 0) + return s.GetToken(YQLParserERROR, 0) } func (s *Json_query_handlerContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Json_query_handlerContext) EMPTY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY, 0) + return s.GetToken(YQLParserEMPTY, 0) } func (s *Json_query_handlerContext) ARRAY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserARRAY, 0) + return s.GetToken(YQLParserARRAY, 0) } func (s *Json_query_handlerContext) OBJECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOBJECT, 0) + return s.GetToken(YQLParserOBJECT, 0) } func (s *Json_query_handlerContext) GetRuleContext() antlr.RuleContext { @@ -15854,13 +15854,13 @@ func (s *Json_query_handlerContext) ToStringTree(ruleNames []string, recog antlr func (s *Json_query_handlerContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_query_handler(s) } } func (s *Json_query_handlerContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_query_handler(s) } } @@ -15868,9 +15868,9 @@ func (s *Json_query_handlerContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_query_handler() (localctx IJson_query_handlerContext) { +func (p *YQLParser) Json_query_handler() (localctx IJson_query_handlerContext) { localctx = NewJson_query_handlerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 106, YQLv1Antlr4ParserRULE_json_query_handler) + p.EnterRule(localctx, 106, YQLParserRULE_json_query_handler) p.SetState(1447) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -15882,7 +15882,7 @@ func (p *YQLv1Antlr4Parser) Json_query_handler() (localctx IJson_query_handlerCo p.EnterOuterAlt(localctx, 1) { p.SetState(1441) - p.Match(YQLv1Antlr4ParserERROR) + p.Match(YQLParserERROR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15894,7 +15894,7 @@ func (p *YQLv1Antlr4Parser) Json_query_handler() (localctx IJson_query_handlerCo p.EnterOuterAlt(localctx, 2) { p.SetState(1442) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15906,7 +15906,7 @@ func (p *YQLv1Antlr4Parser) Json_query_handler() (localctx IJson_query_handlerCo p.EnterOuterAlt(localctx, 3) { p.SetState(1443) - p.Match(YQLv1Antlr4ParserEMPTY) + p.Match(YQLParserEMPTY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15914,7 +15914,7 @@ func (p *YQLv1Antlr4Parser) Json_query_handler() (localctx IJson_query_handlerCo } { p.SetState(1444) - p.Match(YQLv1Antlr4ParserARRAY) + p.Match(YQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15926,7 +15926,7 @@ func (p *YQLv1Antlr4Parser) Json_query_handler() (localctx IJson_query_handlerCo p.EnterOuterAlt(localctx, 4) { p.SetState(1445) - p.Match(YQLv1Antlr4ParserEMPTY) + p.Match(YQLParserEMPTY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15934,7 +15934,7 @@ func (p *YQLv1Antlr4Parser) Json_query_handler() (localctx IJson_query_handlerCo } { p.SetState(1446) - p.Match(YQLv1Antlr4ParserOBJECT) + p.Match(YQLParserOBJECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15993,13 +15993,13 @@ type Json_queryContext struct { func NewEmptyJson_queryContext() *Json_queryContext { var p = new(Json_queryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query + p.RuleIndex = YQLParserRULE_json_query return p } func InitEmptyJson_queryContext(p *Json_queryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query + p.RuleIndex = YQLParserRULE_json_query } func (*Json_queryContext) IsJson_queryContext() {} @@ -16010,7 +16010,7 @@ func NewJson_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_json_query + p.RuleIndex = YQLParserRULE_json_query return p } @@ -16018,11 +16018,11 @@ func NewJson_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *Json_queryContext) GetParser() antlr.Parser { return s.parser } func (s *Json_queryContext) JSON_QUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJSON_QUERY, 0) + return s.GetToken(YQLParserJSON_QUERY, 0) } func (s *Json_queryContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Json_queryContext) Json_common_args() IJson_common_argsContext { @@ -16042,7 +16042,7 @@ func (s *Json_queryContext) Json_common_args() IJson_common_argsContext { } func (s *Json_queryContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Json_queryContext) Json_query_wrapper() IJson_query_wrapperContext { @@ -16062,7 +16062,7 @@ func (s *Json_queryContext) Json_query_wrapper() IJson_query_wrapperContext { } func (s *Json_queryContext) WRAPPER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWRAPPER, 0) + return s.GetToken(YQLParserWRAPPER, 0) } func (s *Json_queryContext) AllJson_query_handler() []IJson_query_handlerContext { @@ -16107,19 +16107,19 @@ func (s *Json_queryContext) Json_query_handler(i int) IJson_query_handlerContext } func (s *Json_queryContext) AllON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserON) + return s.GetTokens(YQLParserON) } func (s *Json_queryContext) ON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, i) + return s.GetToken(YQLParserON, i) } func (s *Json_queryContext) EMPTY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY, 0) + return s.GetToken(YQLParserEMPTY, 0) } func (s *Json_queryContext) ERROR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERROR, 0) + return s.GetToken(YQLParserERROR, 0) } func (s *Json_queryContext) GetRuleContext() antlr.RuleContext { @@ -16132,13 +16132,13 @@ func (s *Json_queryContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Json_queryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJson_query(s) } } func (s *Json_queryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJson_query(s) } } @@ -16146,15 +16146,15 @@ func (s *Json_queryContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { +func (p *YQLParser) Json_query() (localctx IJson_queryContext) { localctx = NewJson_queryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 108, YQLv1Antlr4ParserRULE_json_query) + p.EnterRule(localctx, 108, YQLParserRULE_json_query) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1449) - p.Match(YQLv1Antlr4ParserJSON_QUERY) + p.Match(YQLParserJSON_QUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16162,7 +16162,7 @@ func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { } { p.SetState(1450) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16180,14 +16180,14 @@ func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH || _la == YQLv1Antlr4ParserWITHOUT { + if _la == YQLParserWITH || _la == YQLParserWITHOUT { { p.SetState(1452) p.Json_query_wrapper() } { p.SetState(1453) - p.Match(YQLv1Antlr4ParserWRAPPER) + p.Match(YQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16206,7 +16206,7 @@ func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { } { p.SetState(1458) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16214,7 +16214,7 @@ func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { } { p.SetState(1459) - p.Match(YQLv1Antlr4ParserEMPTY) + p.Match(YQLParserEMPTY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16232,14 +16232,14 @@ func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEMPTY || _la == YQLv1Antlr4ParserERROR || _la == YQLv1Antlr4ParserNULL { + if _la == YQLParserEMPTY || _la == YQLParserERROR || _la == YQLParserNULL { { p.SetState(1463) p.Json_query_handler() } { p.SetState(1464) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16247,7 +16247,7 @@ func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { } { p.SetState(1465) - p.Match(YQLv1Antlr4ParserERROR) + p.Match(YQLParserERROR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16257,7 +16257,7 @@ func (p *YQLv1Antlr4Parser) Json_query() (localctx IJson_queryContext) { } { p.SetState(1469) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16305,13 +16305,13 @@ type Smart_parenthesisContext struct { func NewEmptySmart_parenthesisContext() *Smart_parenthesisContext { var p = new(Smart_parenthesisContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_smart_parenthesis + p.RuleIndex = YQLParserRULE_smart_parenthesis return p } func InitEmptySmart_parenthesisContext(p *Smart_parenthesisContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_smart_parenthesis + p.RuleIndex = YQLParserRULE_smart_parenthesis } func (*Smart_parenthesisContext) IsSmart_parenthesisContext() {} @@ -16322,7 +16322,7 @@ func NewSmart_parenthesisContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_smart_parenthesis + p.RuleIndex = YQLParserRULE_smart_parenthesis return p } @@ -16330,11 +16330,11 @@ func NewSmart_parenthesisContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Smart_parenthesisContext) GetParser() antlr.Parser { return s.parser } func (s *Smart_parenthesisContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Smart_parenthesisContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Smart_parenthesisContext) Named_expr_list() INamed_expr_listContext { @@ -16354,7 +16354,7 @@ func (s *Smart_parenthesisContext) Named_expr_list() INamed_expr_listContext { } func (s *Smart_parenthesisContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Smart_parenthesisContext) GetRuleContext() antlr.RuleContext { @@ -16367,13 +16367,13 @@ func (s *Smart_parenthesisContext) ToStringTree(ruleNames []string, recog antlr. func (s *Smart_parenthesisContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSmart_parenthesis(s) } } func (s *Smart_parenthesisContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSmart_parenthesis(s) } } @@ -16381,15 +16381,15 @@ func (s *Smart_parenthesisContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Smart_parenthesis() (localctx ISmart_parenthesisContext) { +func (p *YQLParser) Smart_parenthesis() (localctx ISmart_parenthesisContext) { localctx = NewSmart_parenthesisContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 110, YQLv1Antlr4ParserRULE_smart_parenthesis) + p.EnterRule(localctx, 110, YQLParserRULE_smart_parenthesis) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1471) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16418,10 +16418,10 @@ func (p *YQLv1Antlr4Parser) Smart_parenthesis() (localctx ISmart_parenthesisCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1475) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16431,7 +16431,7 @@ func (p *YQLv1Antlr4Parser) Smart_parenthesis() (localctx ISmart_parenthesisCont } { p.SetState(1478) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16479,13 +16479,13 @@ type Expr_listContext struct { func NewEmptyExpr_listContext() *Expr_listContext { var p = new(Expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_list + p.RuleIndex = YQLParserRULE_expr_list return p } func InitEmptyExpr_listContext(p *Expr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_list + p.RuleIndex = YQLParserRULE_expr_list } func (*Expr_listContext) IsExpr_listContext() {} @@ -16496,7 +16496,7 @@ func NewExpr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_expr_list + p.RuleIndex = YQLParserRULE_expr_list return p } @@ -16545,11 +16545,11 @@ func (s *Expr_listContext) Expr(i int) IExprContext { } func (s *Expr_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Expr_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Expr_listContext) GetRuleContext() antlr.RuleContext { @@ -16562,13 +16562,13 @@ func (s *Expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Expr_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExpr_list(s) } } func (s *Expr_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExpr_list(s) } } @@ -16576,9 +16576,9 @@ func (s *Expr_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Expr_list() (localctx IExpr_listContext) { +func (p *YQLParser) Expr_list() (localctx IExpr_listContext) { localctx = NewExpr_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 112, YQLv1Antlr4ParserRULE_expr_list) + p.EnterRule(localctx, 112, YQLParserRULE_expr_list) var _alt int p.EnterOuterAlt(localctx, 1) @@ -16599,7 +16599,7 @@ func (p *YQLv1Antlr4Parser) Expr_list() (localctx IExpr_listContext) { if _alt == 1 { { p.SetState(1481) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16666,13 +16666,13 @@ type Pure_column_listContext struct { func NewEmptyPure_column_listContext() *Pure_column_listContext { var p = new(Pure_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_list + p.RuleIndex = YQLParserRULE_pure_column_list return p } func InitEmptyPure_column_listContext(p *Pure_column_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_list + p.RuleIndex = YQLParserRULE_pure_column_list } func (*Pure_column_listContext) IsPure_column_listContext() {} @@ -16683,7 +16683,7 @@ func NewPure_column_listContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_list + p.RuleIndex = YQLParserRULE_pure_column_list return p } @@ -16691,7 +16691,7 @@ func NewPure_column_listContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Pure_column_listContext) GetParser() antlr.Parser { return s.parser } func (s *Pure_column_listContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Pure_column_listContext) AllAn_id() []IAn_idContext { @@ -16736,15 +16736,15 @@ func (s *Pure_column_listContext) An_id(i int) IAn_idContext { } func (s *Pure_column_listContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Pure_column_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Pure_column_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Pure_column_listContext) GetRuleContext() antlr.RuleContext { @@ -16757,13 +16757,13 @@ func (s *Pure_column_listContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Pure_column_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPure_column_list(s) } } func (s *Pure_column_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPure_column_list(s) } } @@ -16771,15 +16771,15 @@ func (s *Pure_column_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Pure_column_list() (localctx IPure_column_listContext) { +func (p *YQLParser) Pure_column_list() (localctx IPure_column_listContext) { localctx = NewPure_column_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 114, YQLv1Antlr4ParserRULE_pure_column_list) + p.EnterRule(localctx, 114, YQLParserRULE_pure_column_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1488) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16797,10 +16797,10 @@ func (p *YQLv1Antlr4Parser) Pure_column_list() (localctx IPure_column_listContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(1490) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16821,7 +16821,7 @@ func (p *YQLv1Antlr4Parser) Pure_column_list() (localctx IPure_column_listContex } { p.SetState(1497) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16867,13 +16867,13 @@ type Pure_column_or_namedContext struct { func NewEmptyPure_column_or_namedContext() *Pure_column_or_namedContext { var p = new(Pure_column_or_namedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_or_named + p.RuleIndex = YQLParserRULE_pure_column_or_named return p } func InitEmptyPure_column_or_namedContext(p *Pure_column_or_namedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_or_named + p.RuleIndex = YQLParserRULE_pure_column_or_named } func (*Pure_column_or_namedContext) IsPure_column_or_namedContext() {} @@ -16884,7 +16884,7 @@ func NewPure_column_or_namedContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_or_named + p.RuleIndex = YQLParserRULE_pure_column_or_named return p } @@ -16933,13 +16933,13 @@ func (s *Pure_column_or_namedContext) ToStringTree(ruleNames []string, recog ant func (s *Pure_column_or_namedContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPure_column_or_named(s) } } func (s *Pure_column_or_namedContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPure_column_or_named(s) } } @@ -16947,9 +16947,9 @@ func (s *Pure_column_or_namedContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Pure_column_or_named() (localctx IPure_column_or_namedContext) { +func (p *YQLParser) Pure_column_or_named() (localctx IPure_column_or_namedContext) { localctx = NewPure_column_or_namedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 116, YQLv1Antlr4ParserRULE_pure_column_or_named) + p.EnterRule(localctx, 116, YQLParserRULE_pure_column_or_named) p.SetState(1501) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -16957,7 +16957,7 @@ func (p *YQLv1Antlr4Parser) Pure_column_or_named() (localctx IPure_column_or_nam } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 1) { p.SetState(1499) @@ -16965,7 +16965,7 @@ func (p *YQLv1Antlr4Parser) Pure_column_or_named() (localctx IPure_column_or_nam } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 2) { p.SetState(1500) @@ -17021,13 +17021,13 @@ type Pure_column_or_named_listContext struct { func NewEmptyPure_column_or_named_listContext() *Pure_column_or_named_listContext { var p = new(Pure_column_or_named_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_or_named_list + p.RuleIndex = YQLParserRULE_pure_column_or_named_list return p } func InitEmptyPure_column_or_named_listContext(p *Pure_column_or_named_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_or_named_list + p.RuleIndex = YQLParserRULE_pure_column_or_named_list } func (*Pure_column_or_named_listContext) IsPure_column_or_named_listContext() {} @@ -17038,7 +17038,7 @@ func NewPure_column_or_named_listContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_pure_column_or_named_list + p.RuleIndex = YQLParserRULE_pure_column_or_named_list return p } @@ -17046,7 +17046,7 @@ func NewPure_column_or_named_listContext(parser antlr.Parser, parent antlr.Parse func (s *Pure_column_or_named_listContext) GetParser() antlr.Parser { return s.parser } func (s *Pure_column_or_named_listContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Pure_column_or_named_listContext) AllPure_column_or_named() []IPure_column_or_namedContext { @@ -17091,15 +17091,15 @@ func (s *Pure_column_or_named_listContext) Pure_column_or_named(i int) IPure_col } func (s *Pure_column_or_named_listContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Pure_column_or_named_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Pure_column_or_named_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Pure_column_or_named_listContext) GetRuleContext() antlr.RuleContext { @@ -17112,13 +17112,13 @@ func (s *Pure_column_or_named_listContext) ToStringTree(ruleNames []string, reco func (s *Pure_column_or_named_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPure_column_or_named_list(s) } } func (s *Pure_column_or_named_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPure_column_or_named_list(s) } } @@ -17126,15 +17126,15 @@ func (s *Pure_column_or_named_listContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Pure_column_or_named_list() (localctx IPure_column_or_named_listContext) { +func (p *YQLParser) Pure_column_or_named_list() (localctx IPure_column_or_named_listContext) { localctx = NewPure_column_or_named_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 118, YQLv1Antlr4ParserRULE_pure_column_or_named_list) + p.EnterRule(localctx, 118, YQLParserRULE_pure_column_or_named_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1503) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17152,10 +17152,10 @@ func (p *YQLv1Antlr4Parser) Pure_column_or_named_list() (localctx IPure_column_o _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(1505) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17176,7 +17176,7 @@ func (p *YQLv1Antlr4Parser) Pure_column_or_named_list() (localctx IPure_column_o } { p.SetState(1512) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17222,13 +17222,13 @@ type Column_nameContext struct { func NewEmptyColumn_nameContext() *Column_nameContext { var p = new(Column_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_name + p.RuleIndex = YQLParserRULE_column_name return p } func InitEmptyColumn_nameContext(p *Column_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_name + p.RuleIndex = YQLParserRULE_column_name } func (*Column_nameContext) IsColumn_nameContext() {} @@ -17239,7 +17239,7 @@ func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_column_name + p.RuleIndex = YQLParserRULE_column_name return p } @@ -17288,13 +17288,13 @@ func (s *Column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Column_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterColumn_name(s) } } func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitColumn_name(s) } } @@ -17302,9 +17302,9 @@ func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Column_name() (localctx IColumn_nameContext) { +func (p *YQLParser) Column_name() (localctx IColumn_nameContext) { localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 120, YQLv1Antlr4ParserRULE_column_name) + p.EnterRule(localctx, 120, YQLParserRULE_column_name) p.EnterOuterAlt(localctx, 1) { p.SetState(1514) @@ -17356,13 +17356,13 @@ type Without_column_nameContext struct { func NewEmptyWithout_column_nameContext() *Without_column_nameContext { var p = new(Without_column_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_without_column_name + p.RuleIndex = YQLParserRULE_without_column_name return p } func InitEmptyWithout_column_nameContext(p *Without_column_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_without_column_name + p.RuleIndex = YQLParserRULE_without_column_name } func (*Without_column_nameContext) IsWithout_column_nameContext() {} @@ -17373,7 +17373,7 @@ func NewWithout_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_without_column_name + p.RuleIndex = YQLParserRULE_without_column_name return p } @@ -17422,7 +17422,7 @@ func (s *Without_column_nameContext) An_id(i int) IAn_idContext { } func (s *Without_column_nameContext) DOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, 0) + return s.GetToken(YQLParserDOT, 0) } func (s *Without_column_nameContext) An_id_without() IAn_id_withoutContext { @@ -17451,13 +17451,13 @@ func (s *Without_column_nameContext) ToStringTree(ruleNames []string, recog antl func (s *Without_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWithout_column_name(s) } } func (s *Without_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWithout_column_name(s) } } @@ -17465,9 +17465,9 @@ func (s *Without_column_nameContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Without_column_name() (localctx IWithout_column_nameContext) { +func (p *YQLParser) Without_column_name() (localctx IWithout_column_nameContext) { localctx = NewWithout_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 122, YQLv1Antlr4ParserRULE_without_column_name) + p.EnterRule(localctx, 122, YQLParserRULE_without_column_name) p.SetState(1522) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -17483,7 +17483,7 @@ func (p *YQLv1Antlr4Parser) Without_column_name() (localctx IWithout_column_name } { p.SetState(1518) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17546,13 +17546,13 @@ type Column_listContext struct { func NewEmptyColumn_listContext() *Column_listContext { var p = new(Column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_list + p.RuleIndex = YQLParserRULE_column_list return p } func InitEmptyColumn_listContext(p *Column_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_list + p.RuleIndex = YQLParserRULE_column_list } func (*Column_listContext) IsColumn_listContext() {} @@ -17563,7 +17563,7 @@ func NewColumn_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_column_list + p.RuleIndex = YQLParserRULE_column_list return p } @@ -17612,11 +17612,11 @@ func (s *Column_listContext) Column_name(i int) IColumn_nameContext { } func (s *Column_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Column_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Column_listContext) GetRuleContext() antlr.RuleContext { @@ -17629,13 +17629,13 @@ func (s *Column_listContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Column_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterColumn_list(s) } } func (s *Column_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitColumn_list(s) } } @@ -17643,9 +17643,9 @@ func (s *Column_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Column_list() (localctx IColumn_listContext) { +func (p *YQLParser) Column_list() (localctx IColumn_listContext) { localctx = NewColumn_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 124, YQLv1Antlr4ParserRULE_column_list) + p.EnterRule(localctx, 124, YQLParserRULE_column_list) var _la int var _alt int @@ -17668,7 +17668,7 @@ func (p *YQLv1Antlr4Parser) Column_list() (localctx IColumn_listContext) { if _alt == 1 { { p.SetState(1525) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17699,10 +17699,10 @@ func (p *YQLv1Antlr4Parser) Column_list() (localctx IColumn_listContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1532) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17752,13 +17752,13 @@ type Without_column_listContext struct { func NewEmptyWithout_column_listContext() *Without_column_listContext { var p = new(Without_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_without_column_list + p.RuleIndex = YQLParserRULE_without_column_list return p } func InitEmptyWithout_column_listContext(p *Without_column_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_without_column_list + p.RuleIndex = YQLParserRULE_without_column_list } func (*Without_column_listContext) IsWithout_column_listContext() {} @@ -17769,7 +17769,7 @@ func NewWithout_column_listContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_without_column_list + p.RuleIndex = YQLParserRULE_without_column_list return p } @@ -17818,11 +17818,11 @@ func (s *Without_column_listContext) Without_column_name(i int) IWithout_column_ } func (s *Without_column_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Without_column_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Without_column_listContext) GetRuleContext() antlr.RuleContext { @@ -17835,13 +17835,13 @@ func (s *Without_column_listContext) ToStringTree(ruleNames []string, recog antl func (s *Without_column_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWithout_column_list(s) } } func (s *Without_column_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWithout_column_list(s) } } @@ -17849,9 +17849,9 @@ func (s *Without_column_listContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Without_column_list() (localctx IWithout_column_listContext) { +func (p *YQLParser) Without_column_list() (localctx IWithout_column_listContext) { localctx = NewWithout_column_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 126, YQLv1Antlr4ParserRULE_without_column_list) + p.EnterRule(localctx, 126, YQLParserRULE_without_column_list) var _la int var _alt int @@ -17874,7 +17874,7 @@ func (p *YQLv1Antlr4Parser) Without_column_list() (localctx IWithout_column_list if _alt == 1 { { p.SetState(1536) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17905,10 +17905,10 @@ func (p *YQLv1Antlr4Parser) Without_column_list() (localctx IWithout_column_list _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1543) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17957,13 +17957,13 @@ type Named_exprContext struct { func NewEmptyNamed_exprContext() *Named_exprContext { var p = new(Named_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_expr + p.RuleIndex = YQLParserRULE_named_expr return p } func InitEmptyNamed_exprContext(p *Named_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_expr + p.RuleIndex = YQLParserRULE_named_expr } func (*Named_exprContext) IsNamed_exprContext() {} @@ -17974,7 +17974,7 @@ func NewNamed_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_named_expr + p.RuleIndex = YQLParserRULE_named_expr return p } @@ -17998,7 +17998,7 @@ func (s *Named_exprContext) Expr() IExprContext { } func (s *Named_exprContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Named_exprContext) An_id_or_type() IAn_id_or_typeContext { @@ -18027,13 +18027,13 @@ func (s *Named_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Named_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNamed_expr(s) } } func (s *Named_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNamed_expr(s) } } @@ -18041,9 +18041,9 @@ func (s *Named_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Named_expr() (localctx INamed_exprContext) { +func (p *YQLParser) Named_expr() (localctx INamed_exprContext) { localctx = NewNamed_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 128, YQLv1Antlr4ParserRULE_named_expr) + p.EnterRule(localctx, 128, YQLParserRULE_named_expr) var _la int p.EnterOuterAlt(localctx, 1) @@ -18059,10 +18059,10 @@ func (p *YQLv1Antlr4Parser) Named_expr() (localctx INamed_exprContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAS { + if _la == YQLParserAS { { p.SetState(1547) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18116,13 +18116,13 @@ type Named_expr_listContext struct { func NewEmptyNamed_expr_listContext() *Named_expr_listContext { var p = new(Named_expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_expr_list + p.RuleIndex = YQLParserRULE_named_expr_list return p } func InitEmptyNamed_expr_listContext(p *Named_expr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_expr_list + p.RuleIndex = YQLParserRULE_named_expr_list } func (*Named_expr_listContext) IsNamed_expr_listContext() {} @@ -18133,7 +18133,7 @@ func NewNamed_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_named_expr_list + p.RuleIndex = YQLParserRULE_named_expr_list return p } @@ -18182,11 +18182,11 @@ func (s *Named_expr_listContext) Named_expr(i int) INamed_exprContext { } func (s *Named_expr_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Named_expr_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Named_expr_listContext) GetRuleContext() antlr.RuleContext { @@ -18199,13 +18199,13 @@ func (s *Named_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Named_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNamed_expr_list(s) } } func (s *Named_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNamed_expr_list(s) } } @@ -18213,9 +18213,9 @@ func (s *Named_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Named_expr_list() (localctx INamed_expr_listContext) { +func (p *YQLParser) Named_expr_list() (localctx INamed_expr_listContext) { localctx = NewNamed_expr_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 130, YQLv1Antlr4ParserRULE_named_expr_list) + p.EnterRule(localctx, 130, YQLParserRULE_named_expr_list) var _alt int p.EnterOuterAlt(localctx, 1) @@ -18236,7 +18236,7 @@ func (p *YQLv1Antlr4Parser) Named_expr_list() (localctx INamed_expr_listContext) if _alt == 1 { { p.SetState(1552) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18304,13 +18304,13 @@ type Invoke_exprContext struct { func NewEmptyInvoke_exprContext() *Invoke_exprContext { var p = new(Invoke_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_invoke_expr + p.RuleIndex = YQLParserRULE_invoke_expr return p } func InitEmptyInvoke_exprContext(p *Invoke_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_invoke_expr + p.RuleIndex = YQLParserRULE_invoke_expr } func (*Invoke_exprContext) IsInvoke_exprContext() {} @@ -18321,7 +18321,7 @@ func NewInvoke_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_invoke_expr + p.RuleIndex = YQLParserRULE_invoke_expr return p } @@ -18329,11 +18329,11 @@ func NewInvoke_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Invoke_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Invoke_exprContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Invoke_exprContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Invoke_exprContext) Invoke_expr_tail() IInvoke_expr_tailContext { @@ -18385,11 +18385,11 @@ func (s *Invoke_exprContext) Named_expr_list() INamed_expr_listContext { } func (s *Invoke_exprContext) ASTERISK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASTERISK, 0) + return s.GetToken(YQLParserASTERISK, 0) } func (s *Invoke_exprContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Invoke_exprContext) GetRuleContext() antlr.RuleContext { @@ -18402,13 +18402,13 @@ func (s *Invoke_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Invoke_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInvoke_expr(s) } } func (s *Invoke_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInvoke_expr(s) } } @@ -18416,15 +18416,15 @@ func (s *Invoke_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Invoke_expr() (localctx IInvoke_exprContext) { +func (p *YQLParser) Invoke_expr() (localctx IInvoke_exprContext) { localctx = NewInvoke_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 132, YQLv1Antlr4ParserRULE_invoke_expr) + p.EnterRule(localctx, 132, YQLParserRULE_invoke_expr) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1559) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18436,7 +18436,7 @@ func (p *YQLv1Antlr4Parser) Invoke_expr() (localctx IInvoke_exprContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSTRUCT_OPEN, YQLv1Antlr4ParserPLUS, YQLv1Antlr4ParserMINUS, YQLv1Antlr4ParserTILDA, YQLv1Antlr4ParserLPAREN, YQLv1Antlr4ParserDOLLAR, YQLv1Antlr4ParserLBRACE_CURLY, YQLv1Antlr4ParserLBRACE_SQUARE, YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFALSE, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTRUE, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED, YQLv1Antlr4ParserDIGITS, YQLv1Antlr4ParserINTEGER_VALUE, YQLv1Antlr4ParserREAL, YQLv1Antlr4ParserBLOB: + case YQLParserSTRUCT_OPEN, YQLParserPLUS, YQLParserMINUS, YQLParserTILDA, YQLParserLPAREN, YQLParserDOLLAR, YQLParserLBRACE_CURLY, YQLParserLBRACE_SQUARE, YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFALSE, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTRUE, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED, YQLParserDIGITS, YQLParserINTEGER_VALUE, YQLParserREAL, YQLParserBLOB: { p.SetState(1560) p.Opt_set_quantifier() @@ -18453,10 +18453,10 @@ func (p *YQLv1Antlr4Parser) Invoke_expr() (localctx IInvoke_exprContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1562) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18466,10 +18466,10 @@ func (p *YQLv1Antlr4Parser) Invoke_expr() (localctx IInvoke_exprContext) { } - case YQLv1Antlr4ParserASTERISK: + case YQLParserASTERISK: { p.SetState(1565) - p.Match(YQLv1Antlr4ParserASTERISK) + p.Match(YQLParserASTERISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18477,7 +18477,7 @@ func (p *YQLv1Antlr4Parser) Invoke_expr() (localctx IInvoke_exprContext) { } - case YQLv1Antlr4ParserRPAREN: + case YQLParserRPAREN: @@ -18485,7 +18485,7 @@ func (p *YQLv1Antlr4Parser) Invoke_expr() (localctx IInvoke_exprContext) { } { p.SetState(1568) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18537,13 +18537,13 @@ type Invoke_expr_tailContext struct { func NewEmptyInvoke_expr_tailContext() *Invoke_expr_tailContext { var p = new(Invoke_expr_tailContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_invoke_expr_tail + p.RuleIndex = YQLParserRULE_invoke_expr_tail return p } func InitEmptyInvoke_expr_tailContext(p *Invoke_expr_tailContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_invoke_expr_tail + p.RuleIndex = YQLParserRULE_invoke_expr_tail } func (*Invoke_expr_tailContext) IsInvoke_expr_tailContext() {} @@ -18554,7 +18554,7 @@ func NewInvoke_expr_tailContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_invoke_expr_tail + p.RuleIndex = YQLParserRULE_invoke_expr_tail return p } @@ -18594,7 +18594,7 @@ func (s *Invoke_expr_tailContext) Filter_clause() IFilter_clauseContext { } func (s *Invoke_expr_tailContext) OVER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOVER, 0) + return s.GetToken(YQLParserOVER, 0) } func (s *Invoke_expr_tailContext) Window_name_or_specification() IWindow_name_or_specificationContext { @@ -18623,13 +18623,13 @@ func (s *Invoke_expr_tailContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Invoke_expr_tailContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInvoke_expr_tail(s) } } func (s *Invoke_expr_tailContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInvoke_expr_tail(s) } } @@ -18637,9 +18637,9 @@ func (s *Invoke_expr_tailContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Invoke_expr_tail() (localctx IInvoke_expr_tailContext) { +func (p *YQLParser) Invoke_expr_tail() (localctx IInvoke_expr_tailContext) { localctx = NewInvoke_expr_tailContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 134, YQLv1Antlr4ParserRULE_invoke_expr_tail) + p.EnterRule(localctx, 134, YQLParserRULE_invoke_expr_tail) var _la int p.EnterOuterAlt(localctx, 1) @@ -18671,10 +18671,10 @@ func (p *YQLv1Antlr4Parser) Invoke_expr_tail() (localctx IInvoke_expr_tailContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserOVER { + if _la == YQLParserOVER { { p.SetState(1575) - p.Match(YQLv1Antlr4ParserOVER) + p.Match(YQLParserOVER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18732,13 +18732,13 @@ type Using_call_exprContext struct { func NewEmptyUsing_call_exprContext() *Using_call_exprContext { var p = new(Using_call_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_using_call_expr + p.RuleIndex = YQLParserRULE_using_call_expr return p } func InitEmptyUsing_call_exprContext(p *Using_call_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_using_call_expr + p.RuleIndex = YQLParserRULE_using_call_expr } func (*Using_call_exprContext) IsUsing_call_exprContext() {} @@ -18749,7 +18749,7 @@ func NewUsing_call_exprContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_using_call_expr + p.RuleIndex = YQLParserRULE_using_call_expr return p } @@ -18814,7 +18814,7 @@ func (s *Using_call_exprContext) An_id_or_type(i int) IAn_id_or_typeContext { } func (s *Using_call_exprContext) NAMESPACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNAMESPACE, 0) + return s.GetToken(YQLParserNAMESPACE, 0) } func (s *Using_call_exprContext) An_id_expr() IAn_id_exprContext { @@ -18850,11 +18850,11 @@ func (s *Using_call_exprContext) Bind_parameter() IBind_parameterContext { } func (s *Using_call_exprContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Using_call_exprContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFUNCTION, 0) + return s.GetToken(YQLParserFUNCTION, 0) } func (s *Using_call_exprContext) GetRuleContext() antlr.RuleContext { @@ -18867,13 +18867,13 @@ func (s *Using_call_exprContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Using_call_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUsing_call_expr(s) } } func (s *Using_call_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUsing_call_expr(s) } } @@ -18881,9 +18881,9 @@ func (s *Using_call_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Using_call_expr() (localctx IUsing_call_exprContext) { +func (p *YQLParser) Using_call_expr() (localctx IUsing_call_exprContext) { localctx = NewUsing_call_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 136, YQLv1Antlr4ParserRULE_using_call_expr) + p.EnterRule(localctx, 136, YQLParserRULE_using_call_expr) p.EnterOuterAlt(localctx, 1) p.SetState(1587) p.GetErrorHandler().Sync(p) @@ -18899,7 +18899,7 @@ func (p *YQLv1Antlr4Parser) Using_call_expr() (localctx IUsing_call_exprContext) } { p.SetState(1580) - p.Match(YQLv1Antlr4ParserNAMESPACE) + p.Match(YQLParserNAMESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18928,7 +18928,7 @@ func (p *YQLv1Antlr4Parser) Using_call_expr() (localctx IUsing_call_exprContext) case 4: { p.SetState(1585) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18936,7 +18936,7 @@ func (p *YQLv1Antlr4Parser) Using_call_expr() (localctx IUsing_call_exprContext) } { p.SetState(1586) - p.Match(YQLv1Antlr4ParserFUNCTION) + p.Match(YQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18991,13 +18991,13 @@ type Key_exprContext struct { func NewEmptyKey_exprContext() *Key_exprContext { var p = new(Key_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_key_expr + p.RuleIndex = YQLParserRULE_key_expr return p } func InitEmptyKey_exprContext(p *Key_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_key_expr + p.RuleIndex = YQLParserRULE_key_expr } func (*Key_exprContext) IsKey_exprContext() {} @@ -19008,7 +19008,7 @@ func NewKey_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_key_expr + p.RuleIndex = YQLParserRULE_key_expr return p } @@ -19016,7 +19016,7 @@ func NewKey_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *Key_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Key_exprContext) LBRACE_SQUARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_SQUARE, 0) + return s.GetToken(YQLParserLBRACE_SQUARE, 0) } func (s *Key_exprContext) Expr() IExprContext { @@ -19036,7 +19036,7 @@ func (s *Key_exprContext) Expr() IExprContext { } func (s *Key_exprContext) RBRACE_SQUARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_SQUARE, 0) + return s.GetToken(YQLParserRBRACE_SQUARE, 0) } func (s *Key_exprContext) GetRuleContext() antlr.RuleContext { @@ -19049,13 +19049,13 @@ func (s *Key_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *Key_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKey_expr(s) } } func (s *Key_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKey_expr(s) } } @@ -19063,13 +19063,13 @@ func (s *Key_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Key_expr() (localctx IKey_exprContext) { +func (p *YQLParser) Key_expr() (localctx IKey_exprContext) { localctx = NewKey_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 138, YQLv1Antlr4ParserRULE_key_expr) + p.EnterRule(localctx, 138, YQLParserRULE_key_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(1591) - p.Match(YQLv1Antlr4ParserLBRACE_SQUARE) + p.Match(YQLParserLBRACE_SQUARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19081,7 +19081,7 @@ func (p *YQLv1Antlr4Parser) Key_expr() (localctx IKey_exprContext) { } { p.SetState(1593) - p.Match(YQLv1Antlr4ParserRBRACE_SQUARE) + p.Match(YQLParserRBRACE_SQUARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19129,13 +19129,13 @@ type When_exprContext struct { func NewEmptyWhen_exprContext() *When_exprContext { var p = new(When_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_when_expr + p.RuleIndex = YQLParserRULE_when_expr return p } func InitEmptyWhen_exprContext(p *When_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_when_expr + p.RuleIndex = YQLParserRULE_when_expr } func (*When_exprContext) IsWhen_exprContext() {} @@ -19146,7 +19146,7 @@ func NewWhen_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_when_expr + p.RuleIndex = YQLParserRULE_when_expr return p } @@ -19154,7 +19154,7 @@ func NewWhen_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *When_exprContext) GetParser() antlr.Parser { return s.parser } func (s *When_exprContext) WHEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHEN, 0) + return s.GetToken(YQLParserWHEN, 0) } func (s *When_exprContext) AllExpr() []IExprContext { @@ -19199,7 +19199,7 @@ func (s *When_exprContext) Expr(i int) IExprContext { } func (s *When_exprContext) THEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTHEN, 0) + return s.GetToken(YQLParserTHEN, 0) } func (s *When_exprContext) GetRuleContext() antlr.RuleContext { @@ -19212,13 +19212,13 @@ func (s *When_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *When_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWhen_expr(s) } } func (s *When_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWhen_expr(s) } } @@ -19226,13 +19226,13 @@ func (s *When_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) When_expr() (localctx IWhen_exprContext) { +func (p *YQLParser) When_expr() (localctx IWhen_exprContext) { localctx = NewWhen_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 140, YQLv1Antlr4ParserRULE_when_expr) + p.EnterRule(localctx, 140, YQLParserRULE_when_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(1595) - p.Match(YQLv1Antlr4ParserWHEN) + p.Match(YQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19244,7 +19244,7 @@ func (p *YQLv1Antlr4Parser) When_expr() (localctx IWhen_exprContext) { } { p.SetState(1597) - p.Match(YQLv1Antlr4ParserTHEN) + p.Match(YQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19302,13 +19302,13 @@ type Literal_valueContext struct { func NewEmptyLiteral_valueContext() *Literal_valueContext { var p = new(Literal_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_literal_value + p.RuleIndex = YQLParserRULE_literal_value return p } func InitEmptyLiteral_valueContext(p *Literal_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_literal_value + p.RuleIndex = YQLParserRULE_literal_value } func (*Literal_valueContext) IsLiteral_valueContext() {} @@ -19319,7 +19319,7 @@ func NewLiteral_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_literal_value + p.RuleIndex = YQLParserRULE_literal_value return p } @@ -19359,27 +19359,27 @@ func (s *Literal_valueContext) Real_() IRealContext { } func (s *Literal_valueContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Literal_valueContext) BLOB() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBLOB, 0) + return s.GetToken(YQLParserBLOB, 0) } func (s *Literal_valueContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Literal_valueContext) CURRENT_TIME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT_TIME, 0) + return s.GetToken(YQLParserCURRENT_TIME, 0) } func (s *Literal_valueContext) CURRENT_DATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT_DATE, 0) + return s.GetToken(YQLParserCURRENT_DATE, 0) } func (s *Literal_valueContext) CURRENT_TIMESTAMP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT_TIMESTAMP, 0) + return s.GetToken(YQLParserCURRENT_TIMESTAMP, 0) } func (s *Literal_valueContext) Bool_value() IBool_valueContext { @@ -19399,7 +19399,7 @@ func (s *Literal_valueContext) Bool_value() IBool_valueContext { } func (s *Literal_valueContext) EMPTY_ACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY_ACTION, 0) + return s.GetToken(YQLParserEMPTY_ACTION, 0) } func (s *Literal_valueContext) GetRuleContext() antlr.RuleContext { @@ -19412,13 +19412,13 @@ func (s *Literal_valueContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Literal_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterLiteral_value(s) } } func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitLiteral_value(s) } } @@ -19426,9 +19426,9 @@ func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { +func (p *YQLParser) Literal_value() (localctx ILiteral_valueContext) { localctx = NewLiteral_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 142, YQLv1Antlr4ParserRULE_literal_value) + p.EnterRule(localctx, 142, YQLParserRULE_literal_value) p.SetState(1610) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -19436,7 +19436,7 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDIGITS, YQLv1Antlr4ParserINTEGER_VALUE: + case YQLParserDIGITS, YQLParserINTEGER_VALUE: p.EnterOuterAlt(localctx, 1) { p.SetState(1600) @@ -19444,7 +19444,7 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserREAL: + case YQLParserREAL: p.EnterOuterAlt(localctx, 2) { p.SetState(1601) @@ -19452,11 +19452,11 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 3) { p.SetState(1602) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19464,11 +19464,11 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserBLOB: + case YQLParserBLOB: p.EnterOuterAlt(localctx, 4) { p.SetState(1603) - p.Match(YQLv1Antlr4ParserBLOB) + p.Match(YQLParserBLOB) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19476,11 +19476,11 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserNULL: + case YQLParserNULL: p.EnterOuterAlt(localctx, 5) { p.SetState(1604) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19488,11 +19488,11 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserCURRENT_TIME: + case YQLParserCURRENT_TIME: p.EnterOuterAlt(localctx, 6) { p.SetState(1605) - p.Match(YQLv1Antlr4ParserCURRENT_TIME) + p.Match(YQLParserCURRENT_TIME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19500,11 +19500,11 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserCURRENT_DATE: + case YQLParserCURRENT_DATE: p.EnterOuterAlt(localctx, 7) { p.SetState(1606) - p.Match(YQLv1Antlr4ParserCURRENT_DATE) + p.Match(YQLParserCURRENT_DATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19512,11 +19512,11 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserCURRENT_TIMESTAMP: + case YQLParserCURRENT_TIMESTAMP: p.EnterOuterAlt(localctx, 8) { p.SetState(1607) - p.Match(YQLv1Antlr4ParserCURRENT_TIMESTAMP) + p.Match(YQLParserCURRENT_TIMESTAMP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19524,7 +19524,7 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserFALSE, YQLv1Antlr4ParserTRUE: + case YQLParserFALSE, YQLParserTRUE: p.EnterOuterAlt(localctx, 9) { p.SetState(1608) @@ -19532,11 +19532,11 @@ func (p *YQLv1Antlr4Parser) Literal_value() (localctx ILiteral_valueContext) { } - case YQLv1Antlr4ParserEMPTY_ACTION: + case YQLParserEMPTY_ACTION: p.EnterOuterAlt(localctx, 10) { p.SetState(1609) - p.Match(YQLv1Antlr4ParserEMPTY_ACTION) + p.Match(YQLParserEMPTY_ACTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19590,13 +19590,13 @@ type Bind_parameterContext struct { func NewEmptyBind_parameterContext() *Bind_parameterContext { var p = new(Bind_parameterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bind_parameter + p.RuleIndex = YQLParserRULE_bind_parameter return p } func InitEmptyBind_parameterContext(p *Bind_parameterContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bind_parameter + p.RuleIndex = YQLParserRULE_bind_parameter } func (*Bind_parameterContext) IsBind_parameterContext() {} @@ -19607,7 +19607,7 @@ func NewBind_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_bind_parameter + p.RuleIndex = YQLParserRULE_bind_parameter return p } @@ -19615,7 +19615,7 @@ func NewBind_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Bind_parameterContext) GetParser() antlr.Parser { return s.parser } func (s *Bind_parameterContext) DOLLAR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOLLAR, 0) + return s.GetToken(YQLParserDOLLAR, 0) } func (s *Bind_parameterContext) An_id_or_type() IAn_id_or_typeContext { @@ -19635,11 +19635,11 @@ func (s *Bind_parameterContext) An_id_or_type() IAn_id_or_typeContext { } func (s *Bind_parameterContext) TRUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTRUE, 0) + return s.GetToken(YQLParserTRUE, 0) } func (s *Bind_parameterContext) FALSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFALSE, 0) + return s.GetToken(YQLParserFALSE, 0) } func (s *Bind_parameterContext) GetRuleContext() antlr.RuleContext { @@ -19652,13 +19652,13 @@ func (s *Bind_parameterContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Bind_parameterContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBind_parameter(s) } } func (s *Bind_parameterContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBind_parameter(s) } } @@ -19666,13 +19666,13 @@ func (s *Bind_parameterContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Bind_parameter() (localctx IBind_parameterContext) { +func (p *YQLParser) Bind_parameter() (localctx IBind_parameterContext) { localctx = NewBind_parameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 144, YQLv1Antlr4ParserRULE_bind_parameter) + p.EnterRule(localctx, 144, YQLParserRULE_bind_parameter) p.EnterOuterAlt(localctx, 1) { p.SetState(1612) - p.Match(YQLv1Antlr4ParserDOLLAR) + p.Match(YQLParserDOLLAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19685,17 +19685,17 @@ func (p *YQLv1Antlr4Parser) Bind_parameter() (localctx IBind_parameterContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(1613) p.An_id_or_type() } - case YQLv1Antlr4ParserTRUE: + case YQLParserTRUE: { p.SetState(1614) - p.Match(YQLv1Antlr4ParserTRUE) + p.Match(YQLParserTRUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19703,10 +19703,10 @@ func (p *YQLv1Antlr4Parser) Bind_parameter() (localctx IBind_parameterContext) { } - case YQLv1Antlr4ParserFALSE: + case YQLParserFALSE: { p.SetState(1615) - p.Match(YQLv1Antlr4ParserFALSE) + p.Match(YQLParserFALSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19759,13 +19759,13 @@ type Opt_bind_parameterContext struct { func NewEmptyOpt_bind_parameterContext() *Opt_bind_parameterContext { var p = new(Opt_bind_parameterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_bind_parameter + p.RuleIndex = YQLParserRULE_opt_bind_parameter return p } func InitEmptyOpt_bind_parameterContext(p *Opt_bind_parameterContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_bind_parameter + p.RuleIndex = YQLParserRULE_opt_bind_parameter } func (*Opt_bind_parameterContext) IsOpt_bind_parameterContext() {} @@ -19776,7 +19776,7 @@ func NewOpt_bind_parameterContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_bind_parameter + p.RuleIndex = YQLParserRULE_opt_bind_parameter return p } @@ -19800,7 +19800,7 @@ func (s *Opt_bind_parameterContext) Bind_parameter() IBind_parameterContext { } func (s *Opt_bind_parameterContext) QUESTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUESTION, 0) + return s.GetToken(YQLParserQUESTION, 0) } func (s *Opt_bind_parameterContext) GetRuleContext() antlr.RuleContext { @@ -19813,13 +19813,13 @@ func (s *Opt_bind_parameterContext) ToStringTree(ruleNames []string, recog antlr func (s *Opt_bind_parameterContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOpt_bind_parameter(s) } } func (s *Opt_bind_parameterContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOpt_bind_parameter(s) } } @@ -19827,9 +19827,9 @@ func (s *Opt_bind_parameterContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Opt_bind_parameter() (localctx IOpt_bind_parameterContext) { +func (p *YQLParser) Opt_bind_parameter() (localctx IOpt_bind_parameterContext) { localctx = NewOpt_bind_parameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 146, YQLv1Antlr4ParserRULE_opt_bind_parameter) + p.EnterRule(localctx, 146, YQLParserRULE_opt_bind_parameter) var _la int p.EnterOuterAlt(localctx, 1) @@ -19845,10 +19845,10 @@ func (p *YQLv1Antlr4Parser) Opt_bind_parameter() (localctx IOpt_bind_parameterCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserQUESTION { + if _la == YQLParserQUESTION { { p.SetState(1619) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19898,13 +19898,13 @@ type Bind_parameter_listContext struct { func NewEmptyBind_parameter_listContext() *Bind_parameter_listContext { var p = new(Bind_parameter_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bind_parameter_list + p.RuleIndex = YQLParserRULE_bind_parameter_list return p } func InitEmptyBind_parameter_listContext(p *Bind_parameter_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bind_parameter_list + p.RuleIndex = YQLParserRULE_bind_parameter_list } func (*Bind_parameter_listContext) IsBind_parameter_listContext() {} @@ -19915,7 +19915,7 @@ func NewBind_parameter_listContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_bind_parameter_list + p.RuleIndex = YQLParserRULE_bind_parameter_list return p } @@ -19964,11 +19964,11 @@ func (s *Bind_parameter_listContext) Bind_parameter(i int) IBind_parameterContex } func (s *Bind_parameter_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Bind_parameter_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Bind_parameter_listContext) GetRuleContext() antlr.RuleContext { @@ -19981,13 +19981,13 @@ func (s *Bind_parameter_listContext) ToStringTree(ruleNames []string, recog antl func (s *Bind_parameter_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBind_parameter_list(s) } } func (s *Bind_parameter_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBind_parameter_list(s) } } @@ -19995,9 +19995,9 @@ func (s *Bind_parameter_listContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Bind_parameter_list() (localctx IBind_parameter_listContext) { +func (p *YQLParser) Bind_parameter_list() (localctx IBind_parameter_listContext) { localctx = NewBind_parameter_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 148, YQLv1Antlr4ParserRULE_bind_parameter_list) + p.EnterRule(localctx, 148, YQLParserRULE_bind_parameter_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -20013,10 +20013,10 @@ func (p *YQLv1Antlr4Parser) Bind_parameter_list() (localctx IBind_parameter_list _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(1623) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20076,13 +20076,13 @@ type Named_bind_parameterContext struct { func NewEmptyNamed_bind_parameterContext() *Named_bind_parameterContext { var p = new(Named_bind_parameterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_bind_parameter + p.RuleIndex = YQLParserRULE_named_bind_parameter return p } func InitEmptyNamed_bind_parameterContext(p *Named_bind_parameterContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_bind_parameter + p.RuleIndex = YQLParserRULE_named_bind_parameter } func (*Named_bind_parameterContext) IsNamed_bind_parameterContext() {} @@ -20093,7 +20093,7 @@ func NewNamed_bind_parameterContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_named_bind_parameter + p.RuleIndex = YQLParserRULE_named_bind_parameter return p } @@ -20142,7 +20142,7 @@ func (s *Named_bind_parameterContext) Bind_parameter(i int) IBind_parameterConte } func (s *Named_bind_parameterContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Named_bind_parameterContext) GetRuleContext() antlr.RuleContext { @@ -20155,13 +20155,13 @@ func (s *Named_bind_parameterContext) ToStringTree(ruleNames []string, recog ant func (s *Named_bind_parameterContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNamed_bind_parameter(s) } } func (s *Named_bind_parameterContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNamed_bind_parameter(s) } } @@ -20169,9 +20169,9 @@ func (s *Named_bind_parameterContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Named_bind_parameter() (localctx INamed_bind_parameterContext) { +func (p *YQLParser) Named_bind_parameter() (localctx INamed_bind_parameterContext) { localctx = NewNamed_bind_parameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 150, YQLv1Antlr4ParserRULE_named_bind_parameter) + p.EnterRule(localctx, 150, YQLParserRULE_named_bind_parameter) var _la int p.EnterOuterAlt(localctx, 1) @@ -20187,10 +20187,10 @@ func (p *YQLv1Antlr4Parser) Named_bind_parameter() (localctx INamed_bind_paramet _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAS { + if _la == YQLParserAS { { p.SetState(1631) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20244,13 +20244,13 @@ type Named_bind_parameter_listContext struct { func NewEmptyNamed_bind_parameter_listContext() *Named_bind_parameter_listContext { var p = new(Named_bind_parameter_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_bind_parameter_list + p.RuleIndex = YQLParserRULE_named_bind_parameter_list return p } func InitEmptyNamed_bind_parameter_listContext(p *Named_bind_parameter_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_bind_parameter_list + p.RuleIndex = YQLParserRULE_named_bind_parameter_list } func (*Named_bind_parameter_listContext) IsNamed_bind_parameter_listContext() {} @@ -20261,7 +20261,7 @@ func NewNamed_bind_parameter_listContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_named_bind_parameter_list + p.RuleIndex = YQLParserRULE_named_bind_parameter_list return p } @@ -20310,11 +20310,11 @@ func (s *Named_bind_parameter_listContext) Named_bind_parameter(i int) INamed_bi } func (s *Named_bind_parameter_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Named_bind_parameter_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Named_bind_parameter_listContext) GetRuleContext() antlr.RuleContext { @@ -20327,13 +20327,13 @@ func (s *Named_bind_parameter_listContext) ToStringTree(ruleNames []string, reco func (s *Named_bind_parameter_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNamed_bind_parameter_list(s) } } func (s *Named_bind_parameter_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNamed_bind_parameter_list(s) } } @@ -20341,9 +20341,9 @@ func (s *Named_bind_parameter_listContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Named_bind_parameter_list() (localctx INamed_bind_parameter_listContext) { +func (p *YQLParser) Named_bind_parameter_list() (localctx INamed_bind_parameter_listContext) { localctx = NewNamed_bind_parameter_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 152, YQLv1Antlr4ParserRULE_named_bind_parameter_list) + p.EnterRule(localctx, 152, YQLParserRULE_named_bind_parameter_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -20359,10 +20359,10 @@ func (p *YQLv1Antlr4Parser) Named_bind_parameter_list() (localctx INamed_bind_pa _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(1636) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20423,13 +20423,13 @@ type Signed_numberContext struct { func NewEmptySigned_numberContext() *Signed_numberContext { var p = new(Signed_numberContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_signed_number + p.RuleIndex = YQLParserRULE_signed_number return p } func InitEmptySigned_numberContext(p *Signed_numberContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_signed_number + p.RuleIndex = YQLParserRULE_signed_number } func (*Signed_numberContext) IsSigned_numberContext() {} @@ -20440,7 +20440,7 @@ func NewSigned_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_signed_number + p.RuleIndex = YQLParserRULE_signed_number return p } @@ -20480,11 +20480,11 @@ func (s *Signed_numberContext) Real_() IRealContext { } func (s *Signed_numberContext) PLUS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPLUS, 0) + return s.GetToken(YQLParserPLUS, 0) } func (s *Signed_numberContext) MINUS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMINUS, 0) + return s.GetToken(YQLParserMINUS, 0) } func (s *Signed_numberContext) GetRuleContext() antlr.RuleContext { @@ -20497,13 +20497,13 @@ func (s *Signed_numberContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Signed_numberContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSigned_number(s) } } func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSigned_number(s) } } @@ -20511,9 +20511,9 @@ func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Signed_number() (localctx ISigned_numberContext) { +func (p *YQLParser) Signed_number() (localctx ISigned_numberContext) { localctx = NewSigned_numberContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 154, YQLv1Antlr4ParserRULE_signed_number) + p.EnterRule(localctx, 154, YQLParserRULE_signed_number) var _la int p.EnterOuterAlt(localctx, 1) @@ -20525,12 +20525,12 @@ func (p *YQLv1Antlr4Parser) Signed_number() (localctx ISigned_numberContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPLUS || _la == YQLv1Antlr4ParserMINUS { + if _la == YQLParserPLUS || _la == YQLParserMINUS { { p.SetState(1643) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserPLUS || _la == YQLv1Antlr4ParserMINUS) { + if !(_la == YQLParserPLUS || _la == YQLParserMINUS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -20546,14 +20546,14 @@ func (p *YQLv1Antlr4Parser) Signed_number() (localctx ISigned_numberContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDIGITS, YQLv1Antlr4ParserINTEGER_VALUE: + case YQLParserDIGITS, YQLParserINTEGER_VALUE: { p.SetState(1646) p.Integer() } - case YQLv1Antlr4ParserREAL: + case YQLParserREAL: { p.SetState(1647) p.Real_() @@ -20604,13 +20604,13 @@ type Type_name_simpleContext struct { func NewEmptyType_name_simpleContext() *Type_name_simpleContext { var p = new(Type_name_simpleContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_simple + p.RuleIndex = YQLParserRULE_type_name_simple return p } func InitEmptyType_name_simpleContext(p *Type_name_simpleContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_simple + p.RuleIndex = YQLParserRULE_type_name_simple } func (*Type_name_simpleContext) IsType_name_simpleContext() {} @@ -20621,7 +20621,7 @@ func NewType_name_simpleContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_simple + p.RuleIndex = YQLParserRULE_type_name_simple return p } @@ -20654,13 +20654,13 @@ func (s *Type_name_simpleContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Type_name_simpleContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_simple(s) } } func (s *Type_name_simpleContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_simple(s) } } @@ -20668,9 +20668,9 @@ func (s *Type_name_simpleContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_simple() (localctx IType_name_simpleContext) { +func (p *YQLParser) Type_name_simple() (localctx IType_name_simpleContext) { localctx = NewType_name_simpleContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 156, YQLv1Antlr4ParserRULE_type_name_simple) + p.EnterRule(localctx, 156, YQLParserRULE_type_name_simple) p.EnterOuterAlt(localctx, 1) { p.SetState(1650) @@ -20716,13 +20716,13 @@ type Integer_or_bindContext struct { func NewEmptyInteger_or_bindContext() *Integer_or_bindContext { var p = new(Integer_or_bindContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_integer_or_bind + p.RuleIndex = YQLParserRULE_integer_or_bind return p } func InitEmptyInteger_or_bindContext(p *Integer_or_bindContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_integer_or_bind + p.RuleIndex = YQLParserRULE_integer_or_bind } func (*Integer_or_bindContext) IsInteger_or_bindContext() {} @@ -20733,7 +20733,7 @@ func NewInteger_or_bindContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_integer_or_bind + p.RuleIndex = YQLParserRULE_integer_or_bind return p } @@ -20782,13 +20782,13 @@ func (s *Integer_or_bindContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Integer_or_bindContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInteger_or_bind(s) } } func (s *Integer_or_bindContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInteger_or_bind(s) } } @@ -20796,9 +20796,9 @@ func (s *Integer_or_bindContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Integer_or_bind() (localctx IInteger_or_bindContext) { +func (p *YQLParser) Integer_or_bind() (localctx IInteger_or_bindContext) { localctx = NewInteger_or_bindContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 158, YQLv1Antlr4ParserRULE_integer_or_bind) + p.EnterRule(localctx, 158, YQLParserRULE_integer_or_bind) p.SetState(1654) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -20806,7 +20806,7 @@ func (p *YQLv1Antlr4Parser) Integer_or_bind() (localctx IInteger_or_bindContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDIGITS, YQLv1Antlr4ParserINTEGER_VALUE: + case YQLParserDIGITS, YQLParserINTEGER_VALUE: p.EnterOuterAlt(localctx, 1) { p.SetState(1652) @@ -20814,7 +20814,7 @@ func (p *YQLv1Antlr4Parser) Integer_or_bind() (localctx IInteger_or_bindContext) } - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 2) { p.SetState(1653) @@ -20867,13 +20867,13 @@ type Type_name_tagContext struct { func NewEmptyType_name_tagContext() *Type_name_tagContext { var p = new(Type_name_tagContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tag + p.RuleIndex = YQLParserRULE_type_name_tag return p } func InitEmptyType_name_tagContext(p *Type_name_tagContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tag + p.RuleIndex = YQLParserRULE_type_name_tag } func (*Type_name_tagContext) IsType_name_tagContext() {} @@ -20884,7 +20884,7 @@ func NewType_name_tagContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tag + p.RuleIndex = YQLParserRULE_type_name_tag return p } @@ -20908,7 +20908,7 @@ func (s *Type_name_tagContext) Id() IIdContext { } func (s *Type_name_tagContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Type_name_tagContext) Bind_parameter() IBind_parameterContext { @@ -20937,13 +20937,13 @@ func (s *Type_name_tagContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Type_name_tagContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_tag(s) } } func (s *Type_name_tagContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_tag(s) } } @@ -20951,9 +20951,9 @@ func (s *Type_name_tagContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_tag() (localctx IType_name_tagContext) { +func (p *YQLParser) Type_name_tag() (localctx IType_name_tagContext) { localctx = NewType_name_tagContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 160, YQLv1Antlr4ParserRULE_type_name_tag) + p.EnterRule(localctx, 160, YQLParserRULE_type_name_tag) p.SetState(1659) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -20961,7 +20961,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tag() (localctx IType_name_tagContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(1656) @@ -20969,11 +20969,11 @@ func (p *YQLv1Antlr4Parser) Type_name_tag() (localctx IType_name_tagContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(1657) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20981,7 +20981,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tag() (localctx IType_name_tagContext) { } - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 3) { p.SetState(1658) @@ -21034,13 +21034,13 @@ type Struct_argContext struct { func NewEmptyStruct_argContext() *Struct_argContext { var p = new(Struct_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_arg + p.RuleIndex = YQLParserRULE_struct_arg return p } func InitEmptyStruct_argContext(p *Struct_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_arg + p.RuleIndex = YQLParserRULE_struct_arg } func (*Struct_argContext) IsStruct_argContext() {} @@ -21051,7 +21051,7 @@ func NewStruct_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_arg + p.RuleIndex = YQLParserRULE_struct_arg return p } @@ -21075,7 +21075,7 @@ func (s *Struct_argContext) Type_name_tag() IType_name_tagContext { } func (s *Struct_argContext) COLON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLON, 0) + return s.GetToken(YQLParserCOLON, 0) } func (s *Struct_argContext) Type_name_or_bind() IType_name_or_bindContext { @@ -21104,13 +21104,13 @@ func (s *Struct_argContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Struct_argContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterStruct_arg(s) } } func (s *Struct_argContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitStruct_arg(s) } } @@ -21118,9 +21118,9 @@ func (s *Struct_argContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Struct_arg() (localctx IStruct_argContext) { +func (p *YQLParser) Struct_arg() (localctx IStruct_argContext) { localctx = NewStruct_argContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 162, YQLv1Antlr4ParserRULE_struct_arg) + p.EnterRule(localctx, 162, YQLParserRULE_struct_arg) p.EnterOuterAlt(localctx, 1) { p.SetState(1661) @@ -21128,7 +21128,7 @@ func (p *YQLv1Antlr4Parser) Struct_arg() (localctx IStruct_argContext) { } { p.SetState(1662) - p.Match(YQLv1Antlr4ParserCOLON) + p.Match(YQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21181,13 +21181,13 @@ type Struct_arg_positionalContext struct { func NewEmptyStruct_arg_positionalContext() *Struct_arg_positionalContext { var p = new(Struct_arg_positionalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_arg_positional + p.RuleIndex = YQLParserRULE_struct_arg_positional return p } func InitEmptyStruct_arg_positionalContext(p *Struct_arg_positionalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_arg_positional + p.RuleIndex = YQLParserRULE_struct_arg_positional } func (*Struct_arg_positionalContext) IsStruct_arg_positionalContext() {} @@ -21198,7 +21198,7 @@ func NewStruct_arg_positionalContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_struct_arg_positional + p.RuleIndex = YQLParserRULE_struct_arg_positional return p } @@ -21238,15 +21238,15 @@ func (s *Struct_arg_positionalContext) Type_name_or_bind() IType_name_or_bindCon } func (s *Struct_arg_positionalContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Struct_arg_positionalContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Struct_arg_positionalContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Struct_arg_positionalContext) GetRuleContext() antlr.RuleContext { @@ -21259,13 +21259,13 @@ func (s *Struct_arg_positionalContext) ToStringTree(ruleNames []string, recog an func (s *Struct_arg_positionalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterStruct_arg_positional(s) } } func (s *Struct_arg_positionalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitStruct_arg_positional(s) } } @@ -21273,9 +21273,9 @@ func (s *Struct_arg_positionalContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Struct_arg_positional() (localctx IStruct_arg_positionalContext) { +func (p *YQLParser) Struct_arg_positional() (localctx IStruct_arg_positionalContext) { localctx = NewStruct_arg_positionalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 164, YQLv1Antlr4ParserRULE_struct_arg_positional) + p.EnterRule(localctx, 164, YQLParserRULE_struct_arg_positional) var _la int p.SetState(1677) @@ -21303,7 +21303,7 @@ func (p *YQLv1Antlr4Parser) Struct_arg_positional() (localctx IStruct_arg_positi _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT || _la == YQLv1Antlr4ParserNULL { + if _la == YQLParserNOT || _la == YQLParserNULL { p.SetState(1668) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -21312,10 +21312,10 @@ func (p *YQLv1Antlr4Parser) Struct_arg_positional() (localctx IStruct_arg_positi _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT { + if _la == YQLParserNOT { { p.SetState(1667) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21325,7 +21325,7 @@ func (p *YQLv1Antlr4Parser) Struct_arg_positional() (localctx IStruct_arg_positi } { p.SetState(1670) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21343,7 +21343,7 @@ func (p *YQLv1Antlr4Parser) Struct_arg_positional() (localctx IStruct_arg_positi } { p.SetState(1674) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21397,13 +21397,13 @@ type Variant_argContext struct { func NewEmptyVariant_argContext() *Variant_argContext { var p = new(Variant_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_variant_arg + p.RuleIndex = YQLParserRULE_variant_arg return p } func InitEmptyVariant_argContext(p *Variant_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_variant_arg + p.RuleIndex = YQLParserRULE_variant_arg } func (*Variant_argContext) IsVariant_argContext() {} @@ -21414,7 +21414,7 @@ func NewVariant_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_variant_arg + p.RuleIndex = YQLParserRULE_variant_arg return p } @@ -21454,7 +21454,7 @@ func (s *Variant_argContext) Type_name_tag() IType_name_tagContext { } func (s *Variant_argContext) COLON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLON, 0) + return s.GetToken(YQLParserCOLON, 0) } func (s *Variant_argContext) GetRuleContext() antlr.RuleContext { @@ -21467,13 +21467,13 @@ func (s *Variant_argContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Variant_argContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterVariant_arg(s) } } func (s *Variant_argContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitVariant_arg(s) } } @@ -21481,9 +21481,9 @@ func (s *Variant_argContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Variant_arg() (localctx IVariant_argContext) { +func (p *YQLParser) Variant_arg() (localctx IVariant_argContext) { localctx = NewVariant_argContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 166, YQLv1Antlr4ParserRULE_variant_arg) + p.EnterRule(localctx, 166, YQLParserRULE_variant_arg) p.EnterOuterAlt(localctx, 1) p.SetState(1682) p.GetErrorHandler().Sync(p) @@ -21496,7 +21496,7 @@ func (p *YQLv1Antlr4Parser) Variant_arg() (localctx IVariant_argContext) { } { p.SetState(1680) - p.Match(YQLv1Antlr4ParserCOLON) + p.Match(YQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21552,13 +21552,13 @@ type Callable_argContext struct { func NewEmptyCallable_argContext() *Callable_argContext { var p = new(Callable_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_callable_arg + p.RuleIndex = YQLParserRULE_callable_arg return p } func InitEmptyCallable_argContext(p *Callable_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_callable_arg + p.RuleIndex = YQLParserRULE_callable_arg } func (*Callable_argContext) IsCallable_argContext() {} @@ -21569,7 +21569,7 @@ func NewCallable_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_callable_arg + p.RuleIndex = YQLParserRULE_callable_arg return p } @@ -21593,15 +21593,15 @@ func (s *Callable_argContext) Variant_arg() IVariant_argContext { } func (s *Callable_argContext) LBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_CURLY, 0) + return s.GetToken(YQLParserLBRACE_CURLY, 0) } func (s *Callable_argContext) AUTOMAP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAUTOMAP, 0) + return s.GetToken(YQLParserAUTOMAP, 0) } func (s *Callable_argContext) RBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_CURLY, 0) + return s.GetToken(YQLParserRBRACE_CURLY, 0) } func (s *Callable_argContext) GetRuleContext() antlr.RuleContext { @@ -21614,13 +21614,13 @@ func (s *Callable_argContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Callable_argContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCallable_arg(s) } } func (s *Callable_argContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCallable_arg(s) } } @@ -21628,9 +21628,9 @@ func (s *Callable_argContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Callable_arg() (localctx ICallable_argContext) { +func (p *YQLParser) Callable_arg() (localctx ICallable_argContext) { localctx = NewCallable_argContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 168, YQLv1Antlr4ParserRULE_callable_arg) + p.EnterRule(localctx, 168, YQLParserRULE_callable_arg) var _la int p.EnterOuterAlt(localctx, 1) @@ -21646,10 +21646,10 @@ func (p *YQLv1Antlr4Parser) Callable_arg() (localctx ICallable_argContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLBRACE_CURLY { + if _la == YQLParserLBRACE_CURLY { { p.SetState(1687) - p.Match(YQLv1Antlr4ParserLBRACE_CURLY) + p.Match(YQLParserLBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21657,7 +21657,7 @@ func (p *YQLv1Antlr4Parser) Callable_arg() (localctx ICallable_argContext) { } { p.SetState(1688) - p.Match(YQLv1Antlr4ParserAUTOMAP) + p.Match(YQLParserAUTOMAP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21665,7 +21665,7 @@ func (p *YQLv1Antlr4Parser) Callable_arg() (localctx ICallable_argContext) { } { p.SetState(1689) - p.Match(YQLv1Antlr4ParserRBRACE_CURLY) + p.Match(YQLParserRBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21715,13 +21715,13 @@ type Callable_arg_listContext struct { func NewEmptyCallable_arg_listContext() *Callable_arg_listContext { var p = new(Callable_arg_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_callable_arg_list + p.RuleIndex = YQLParserRULE_callable_arg_list return p } func InitEmptyCallable_arg_listContext(p *Callable_arg_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_callable_arg_list + p.RuleIndex = YQLParserRULE_callable_arg_list } func (*Callable_arg_listContext) IsCallable_arg_listContext() {} @@ -21732,7 +21732,7 @@ func NewCallable_arg_listContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_callable_arg_list + p.RuleIndex = YQLParserRULE_callable_arg_list return p } @@ -21781,11 +21781,11 @@ func (s *Callable_arg_listContext) Callable_arg(i int) ICallable_argContext { } func (s *Callable_arg_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Callable_arg_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Callable_arg_listContext) GetRuleContext() antlr.RuleContext { @@ -21798,13 +21798,13 @@ func (s *Callable_arg_listContext) ToStringTree(ruleNames []string, recog antlr. func (s *Callable_arg_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCallable_arg_list(s) } } func (s *Callable_arg_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCallable_arg_list(s) } } @@ -21812,9 +21812,9 @@ func (s *Callable_arg_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Callable_arg_list() (localctx ICallable_arg_listContext) { +func (p *YQLParser) Callable_arg_list() (localctx ICallable_arg_listContext) { localctx = NewCallable_arg_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 170, YQLv1Antlr4ParserRULE_callable_arg_list) + p.EnterRule(localctx, 170, YQLParserRULE_callable_arg_list) var _alt int p.EnterOuterAlt(localctx, 1) @@ -21835,7 +21835,7 @@ func (p *YQLv1Antlr4Parser) Callable_arg_list() (localctx ICallable_arg_listCont if _alt == 1 { { p.SetState(1693) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21902,13 +21902,13 @@ type Type_name_decimalContext struct { func NewEmptyType_name_decimalContext() *Type_name_decimalContext { var p = new(Type_name_decimalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_decimal + p.RuleIndex = YQLParserRULE_type_name_decimal return p } func InitEmptyType_name_decimalContext(p *Type_name_decimalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_decimal + p.RuleIndex = YQLParserRULE_type_name_decimal } func (*Type_name_decimalContext) IsType_name_decimalContext() {} @@ -21919,7 +21919,7 @@ func NewType_name_decimalContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_decimal + p.RuleIndex = YQLParserRULE_type_name_decimal return p } @@ -21927,11 +21927,11 @@ func NewType_name_decimalContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Type_name_decimalContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_decimalContext) DECIMAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDECIMAL, 0) + return s.GetToken(YQLParserDECIMAL, 0) } func (s *Type_name_decimalContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Type_name_decimalContext) AllInteger_or_bind() []IInteger_or_bindContext { @@ -21976,11 +21976,11 @@ func (s *Type_name_decimalContext) Integer_or_bind(i int) IInteger_or_bindContex } func (s *Type_name_decimalContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Type_name_decimalContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Type_name_decimalContext) GetRuleContext() antlr.RuleContext { @@ -21993,13 +21993,13 @@ func (s *Type_name_decimalContext) ToStringTree(ruleNames []string, recog antlr. func (s *Type_name_decimalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_decimal(s) } } func (s *Type_name_decimalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_decimal(s) } } @@ -22007,13 +22007,13 @@ func (s *Type_name_decimalContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_decimal() (localctx IType_name_decimalContext) { +func (p *YQLParser) Type_name_decimal() (localctx IType_name_decimalContext) { localctx = NewType_name_decimalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 172, YQLv1Antlr4ParserRULE_type_name_decimal) + p.EnterRule(localctx, 172, YQLParserRULE_type_name_decimal) p.EnterOuterAlt(localctx, 1) { p.SetState(1700) - p.Match(YQLv1Antlr4ParserDECIMAL) + p.Match(YQLParserDECIMAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22021,7 +22021,7 @@ func (p *YQLv1Antlr4Parser) Type_name_decimal() (localctx IType_name_decimalCont } { p.SetState(1701) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22033,7 +22033,7 @@ func (p *YQLv1Antlr4Parser) Type_name_decimal() (localctx IType_name_decimalCont } { p.SetState(1703) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22045,7 +22045,7 @@ func (p *YQLv1Antlr4Parser) Type_name_decimal() (localctx IType_name_decimalCont } { p.SetState(1705) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22093,13 +22093,13 @@ type Type_name_optionalContext struct { func NewEmptyType_name_optionalContext() *Type_name_optionalContext { var p = new(Type_name_optionalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_optional + p.RuleIndex = YQLParserRULE_type_name_optional return p } func InitEmptyType_name_optionalContext(p *Type_name_optionalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_optional + p.RuleIndex = YQLParserRULE_type_name_optional } func (*Type_name_optionalContext) IsType_name_optionalContext() {} @@ -22110,7 +22110,7 @@ func NewType_name_optionalContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_optional + p.RuleIndex = YQLParserRULE_type_name_optional return p } @@ -22118,11 +22118,11 @@ func NewType_name_optionalContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Type_name_optionalContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_optionalContext) OPTIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOPTIONAL, 0) + return s.GetToken(YQLParserOPTIONAL, 0) } func (s *Type_name_optionalContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_optionalContext) Type_name_or_bind() IType_name_or_bindContext { @@ -22142,7 +22142,7 @@ func (s *Type_name_optionalContext) Type_name_or_bind() IType_name_or_bindContex } func (s *Type_name_optionalContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_optionalContext) GetRuleContext() antlr.RuleContext { @@ -22155,13 +22155,13 @@ func (s *Type_name_optionalContext) ToStringTree(ruleNames []string, recog antlr func (s *Type_name_optionalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_optional(s) } } func (s *Type_name_optionalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_optional(s) } } @@ -22169,13 +22169,13 @@ func (s *Type_name_optionalContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_optional() (localctx IType_name_optionalContext) { +func (p *YQLParser) Type_name_optional() (localctx IType_name_optionalContext) { localctx = NewType_name_optionalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 174, YQLv1Antlr4ParserRULE_type_name_optional) + p.EnterRule(localctx, 174, YQLParserRULE_type_name_optional) p.EnterOuterAlt(localctx, 1) { p.SetState(1707) - p.Match(YQLv1Antlr4ParserOPTIONAL) + p.Match(YQLParserOPTIONAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22183,7 +22183,7 @@ func (p *YQLv1Antlr4Parser) Type_name_optional() (localctx IType_name_optionalCo } { p.SetState(1708) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22195,7 +22195,7 @@ func (p *YQLv1Antlr4Parser) Type_name_optional() (localctx IType_name_optionalCo } { p.SetState(1710) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22247,13 +22247,13 @@ type Type_name_tupleContext struct { func NewEmptyType_name_tupleContext() *Type_name_tupleContext { var p = new(Type_name_tupleContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tuple + p.RuleIndex = YQLParserRULE_type_name_tuple return p } func InitEmptyType_name_tupleContext(p *Type_name_tupleContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tuple + p.RuleIndex = YQLParserRULE_type_name_tuple } func (*Type_name_tupleContext) IsType_name_tupleContext() {} @@ -22264,7 +22264,7 @@ func NewType_name_tupleContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tuple + p.RuleIndex = YQLParserRULE_type_name_tuple return p } @@ -22272,19 +22272,19 @@ func NewType_name_tupleContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Type_name_tupleContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_tupleContext) TUPLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTUPLE, 0) + return s.GetToken(YQLParserTUPLE, 0) } func (s *Type_name_tupleContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_tupleContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_tupleContext) NOT_EQUALS2() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT_EQUALS2, 0) + return s.GetToken(YQLParserNOT_EQUALS2, 0) } func (s *Type_name_tupleContext) AllType_name_or_bind() []IType_name_or_bindContext { @@ -22329,11 +22329,11 @@ func (s *Type_name_tupleContext) Type_name_or_bind(i int) IType_name_or_bindCont } func (s *Type_name_tupleContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Type_name_tupleContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Type_name_tupleContext) GetRuleContext() antlr.RuleContext { @@ -22346,13 +22346,13 @@ func (s *Type_name_tupleContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Type_name_tupleContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_tuple(s) } } func (s *Type_name_tupleContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_tuple(s) } } @@ -22360,9 +22360,9 @@ func (s *Type_name_tupleContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) { +func (p *YQLParser) Type_name_tuple() (localctx IType_name_tupleContext) { localctx = NewType_name_tupleContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 176, YQLv1Antlr4ParserRULE_type_name_tuple) + p.EnterRule(localctx, 176, YQLParserRULE_type_name_tuple) var _la int var _alt int @@ -22370,7 +22370,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) p.EnterOuterAlt(localctx, 1) { p.SetState(1712) - p.Match(YQLv1Antlr4ParserTUPLE) + p.Match(YQLParserTUPLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22383,10 +22383,10 @@ func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLESS: + case YQLParserLESS: { p.SetState(1713) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22400,7 +22400,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDOLLAR || ((int64((_la - 67)) & ^0x3f) == 0 && ((int64(1) << (_la - 67)) & 1126037480013825) != 0) || _la == YQLv1Antlr4ParserFLOW || _la == YQLv1Antlr4ParserLIST || ((int64((_la - 210)) & ^0x3f) == 0 && ((int64(1) << (_la - 210)) & 1152921642045800449) != 0) || ((int64((_la - 277)) & ^0x3f) == 0 && ((int64(1) << (_la - 277)) & 985299861639171) != 0) { + if _la == YQLParserDOLLAR || ((int64((_la - 67)) & ^0x3f) == 0 && ((int64(1) << (_la - 67)) & 1126037480013825) != 0) || _la == YQLParserFLOW || _la == YQLParserLIST || ((int64((_la - 210)) & ^0x3f) == 0 && ((int64(1) << (_la - 210)) & 1152921642045800449) != 0) || ((int64((_la - 277)) & ^0x3f) == 0 && ((int64(1) << (_la - 277)) & 985299861639171) != 0) { { p.SetState(1714) p.Type_name_or_bind() @@ -22418,7 +22418,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) if _alt == 1 { { p.SetState(1715) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22449,10 +22449,10 @@ func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1722) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22464,7 +22464,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) } { p.SetState(1727) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22472,10 +22472,10 @@ func (p *YQLv1Antlr4Parser) Type_name_tuple() (localctx IType_name_tupleContext) } - case YQLv1Antlr4ParserNOT_EQUALS2: + case YQLParserNOT_EQUALS2: { p.SetState(1728) - p.Match(YQLv1Antlr4ParserNOT_EQUALS2) + p.Match(YQLParserNOT_EQUALS2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22534,13 +22534,13 @@ type Type_name_structContext struct { func NewEmptyType_name_structContext() *Type_name_structContext { var p = new(Type_name_structContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_struct + p.RuleIndex = YQLParserRULE_type_name_struct return p } func InitEmptyType_name_structContext(p *Type_name_structContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_struct + p.RuleIndex = YQLParserRULE_type_name_struct } func (*Type_name_structContext) IsType_name_structContext() {} @@ -22551,7 +22551,7 @@ func NewType_name_structContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_struct + p.RuleIndex = YQLParserRULE_type_name_struct return p } @@ -22559,19 +22559,19 @@ func NewType_name_structContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Type_name_structContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_structContext) STRUCT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRUCT, 0) + return s.GetToken(YQLParserSTRUCT, 0) } func (s *Type_name_structContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_structContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_structContext) NOT_EQUALS2() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT_EQUALS2, 0) + return s.GetToken(YQLParserNOT_EQUALS2, 0) } func (s *Type_name_structContext) AllStruct_arg() []IStruct_argContext { @@ -22616,11 +22616,11 @@ func (s *Type_name_structContext) Struct_arg(i int) IStruct_argContext { } func (s *Type_name_structContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Type_name_structContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Type_name_structContext) GetRuleContext() antlr.RuleContext { @@ -22633,13 +22633,13 @@ func (s *Type_name_structContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Type_name_structContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_struct(s) } } func (s *Type_name_structContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_struct(s) } } @@ -22647,9 +22647,9 @@ func (s *Type_name_structContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_struct() (localctx IType_name_structContext) { +func (p *YQLParser) Type_name_struct() (localctx IType_name_structContext) { localctx = NewType_name_structContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 178, YQLv1Antlr4ParserRULE_type_name_struct) + p.EnterRule(localctx, 178, YQLParserRULE_type_name_struct) var _la int var _alt int @@ -22657,7 +22657,7 @@ func (p *YQLv1Antlr4Parser) Type_name_struct() (localctx IType_name_structContex p.EnterOuterAlt(localctx, 1) { p.SetState(1731) - p.Match(YQLv1Antlr4ParserSTRUCT) + p.Match(YQLParserSTRUCT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22670,10 +22670,10 @@ func (p *YQLv1Antlr4Parser) Type_name_struct() (localctx IType_name_structContex } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLESS: + case YQLParserLESS: { p.SetState(1732) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22705,7 +22705,7 @@ func (p *YQLv1Antlr4Parser) Type_name_struct() (localctx IType_name_structContex if _alt == 1 { { p.SetState(1734) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22736,10 +22736,10 @@ func (p *YQLv1Antlr4Parser) Type_name_struct() (localctx IType_name_structContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1741) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22751,7 +22751,7 @@ func (p *YQLv1Antlr4Parser) Type_name_struct() (localctx IType_name_structContex } { p.SetState(1746) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22759,10 +22759,10 @@ func (p *YQLv1Antlr4Parser) Type_name_struct() (localctx IType_name_structContex } - case YQLv1Antlr4ParserNOT_EQUALS2: + case YQLParserNOT_EQUALS2: { p.SetState(1747) - p.Match(YQLv1Antlr4ParserNOT_EQUALS2) + p.Match(YQLParserNOT_EQUALS2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22820,13 +22820,13 @@ type Type_name_variantContext struct { func NewEmptyType_name_variantContext() *Type_name_variantContext { var p = new(Type_name_variantContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_variant + p.RuleIndex = YQLParserRULE_type_name_variant return p } func InitEmptyType_name_variantContext(p *Type_name_variantContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_variant + p.RuleIndex = YQLParserRULE_type_name_variant } func (*Type_name_variantContext) IsType_name_variantContext() {} @@ -22837,7 +22837,7 @@ func NewType_name_variantContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_variant + p.RuleIndex = YQLParserRULE_type_name_variant return p } @@ -22845,11 +22845,11 @@ func NewType_name_variantContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Type_name_variantContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_variantContext) VARIANT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVARIANT, 0) + return s.GetToken(YQLParserVARIANT, 0) } func (s *Type_name_variantContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_variantContext) AllVariant_arg() []IVariant_argContext { @@ -22894,15 +22894,15 @@ func (s *Type_name_variantContext) Variant_arg(i int) IVariant_argContext { } func (s *Type_name_variantContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_variantContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Type_name_variantContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Type_name_variantContext) GetRuleContext() antlr.RuleContext { @@ -22915,13 +22915,13 @@ func (s *Type_name_variantContext) ToStringTree(ruleNames []string, recog antlr. func (s *Type_name_variantContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_variant(s) } } func (s *Type_name_variantContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_variant(s) } } @@ -22929,9 +22929,9 @@ func (s *Type_name_variantContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_variant() (localctx IType_name_variantContext) { +func (p *YQLParser) Type_name_variant() (localctx IType_name_variantContext) { localctx = NewType_name_variantContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 180, YQLv1Antlr4ParserRULE_type_name_variant) + p.EnterRule(localctx, 180, YQLParserRULE_type_name_variant) var _la int var _alt int @@ -22939,7 +22939,7 @@ func (p *YQLv1Antlr4Parser) Type_name_variant() (localctx IType_name_variantCont p.EnterOuterAlt(localctx, 1) { p.SetState(1750) - p.Match(YQLv1Antlr4ParserVARIANT) + p.Match(YQLParserVARIANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22947,7 +22947,7 @@ func (p *YQLv1Antlr4Parser) Type_name_variant() (localctx IType_name_variantCont } { p.SetState(1751) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22970,7 +22970,7 @@ func (p *YQLv1Antlr4Parser) Type_name_variant() (localctx IType_name_variantCont if _alt == 1 { { p.SetState(1753) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23001,10 +23001,10 @@ func (p *YQLv1Antlr4Parser) Type_name_variant() (localctx IType_name_variantCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1760) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23014,7 +23014,7 @@ func (p *YQLv1Antlr4Parser) Type_name_variant() (localctx IType_name_variantCont } { p.SetState(1763) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23062,13 +23062,13 @@ type Type_name_listContext struct { func NewEmptyType_name_listContext() *Type_name_listContext { var p = new(Type_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_list + p.RuleIndex = YQLParserRULE_type_name_list return p } func InitEmptyType_name_listContext(p *Type_name_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_list + p.RuleIndex = YQLParserRULE_type_name_list } func (*Type_name_listContext) IsType_name_listContext() {} @@ -23079,7 +23079,7 @@ func NewType_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_list + p.RuleIndex = YQLParserRULE_type_name_list return p } @@ -23087,11 +23087,11 @@ func NewType_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Type_name_listContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_listContext) LIST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIST, 0) + return s.GetToken(YQLParserLIST, 0) } func (s *Type_name_listContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_listContext) Type_name_or_bind() IType_name_or_bindContext { @@ -23111,7 +23111,7 @@ func (s *Type_name_listContext) Type_name_or_bind() IType_name_or_bindContext { } func (s *Type_name_listContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_listContext) GetRuleContext() antlr.RuleContext { @@ -23124,13 +23124,13 @@ func (s *Type_name_listContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Type_name_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_list(s) } } func (s *Type_name_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_list(s) } } @@ -23138,13 +23138,13 @@ func (s *Type_name_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_list() (localctx IType_name_listContext) { +func (p *YQLParser) Type_name_list() (localctx IType_name_listContext) { localctx = NewType_name_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 182, YQLv1Antlr4ParserRULE_type_name_list) + p.EnterRule(localctx, 182, YQLParserRULE_type_name_list) p.EnterOuterAlt(localctx, 1) { p.SetState(1765) - p.Match(YQLv1Antlr4ParserLIST) + p.Match(YQLParserLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23152,7 +23152,7 @@ func (p *YQLv1Antlr4Parser) Type_name_list() (localctx IType_name_listContext) { } { p.SetState(1766) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23164,7 +23164,7 @@ func (p *YQLv1Antlr4Parser) Type_name_list() (localctx IType_name_listContext) { } { p.SetState(1768) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23212,13 +23212,13 @@ type Type_name_streamContext struct { func NewEmptyType_name_streamContext() *Type_name_streamContext { var p = new(Type_name_streamContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_stream + p.RuleIndex = YQLParserRULE_type_name_stream return p } func InitEmptyType_name_streamContext(p *Type_name_streamContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_stream + p.RuleIndex = YQLParserRULE_type_name_stream } func (*Type_name_streamContext) IsType_name_streamContext() {} @@ -23229,7 +23229,7 @@ func NewType_name_streamContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_stream + p.RuleIndex = YQLParserRULE_type_name_stream return p } @@ -23237,11 +23237,11 @@ func NewType_name_streamContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Type_name_streamContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_streamContext) STREAM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTREAM, 0) + return s.GetToken(YQLParserSTREAM, 0) } func (s *Type_name_streamContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_streamContext) Type_name_or_bind() IType_name_or_bindContext { @@ -23261,7 +23261,7 @@ func (s *Type_name_streamContext) Type_name_or_bind() IType_name_or_bindContext } func (s *Type_name_streamContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_streamContext) GetRuleContext() antlr.RuleContext { @@ -23274,13 +23274,13 @@ func (s *Type_name_streamContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Type_name_streamContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_stream(s) } } func (s *Type_name_streamContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_stream(s) } } @@ -23288,13 +23288,13 @@ func (s *Type_name_streamContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_stream() (localctx IType_name_streamContext) { +func (p *YQLParser) Type_name_stream() (localctx IType_name_streamContext) { localctx = NewType_name_streamContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 184, YQLv1Antlr4ParserRULE_type_name_stream) + p.EnterRule(localctx, 184, YQLParserRULE_type_name_stream) p.EnterOuterAlt(localctx, 1) { p.SetState(1770) - p.Match(YQLv1Antlr4ParserSTREAM) + p.Match(YQLParserSTREAM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23302,7 +23302,7 @@ func (p *YQLv1Antlr4Parser) Type_name_stream() (localctx IType_name_streamContex } { p.SetState(1771) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23314,7 +23314,7 @@ func (p *YQLv1Antlr4Parser) Type_name_stream() (localctx IType_name_streamContex } { p.SetState(1773) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23362,13 +23362,13 @@ type Type_name_flowContext struct { func NewEmptyType_name_flowContext() *Type_name_flowContext { var p = new(Type_name_flowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_flow + p.RuleIndex = YQLParserRULE_type_name_flow return p } func InitEmptyType_name_flowContext(p *Type_name_flowContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_flow + p.RuleIndex = YQLParserRULE_type_name_flow } func (*Type_name_flowContext) IsType_name_flowContext() {} @@ -23379,7 +23379,7 @@ func NewType_name_flowContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_flow + p.RuleIndex = YQLParserRULE_type_name_flow return p } @@ -23387,11 +23387,11 @@ func NewType_name_flowContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Type_name_flowContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_flowContext) FLOW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFLOW, 0) + return s.GetToken(YQLParserFLOW, 0) } func (s *Type_name_flowContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_flowContext) Type_name_or_bind() IType_name_or_bindContext { @@ -23411,7 +23411,7 @@ func (s *Type_name_flowContext) Type_name_or_bind() IType_name_or_bindContext { } func (s *Type_name_flowContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_flowContext) GetRuleContext() antlr.RuleContext { @@ -23424,13 +23424,13 @@ func (s *Type_name_flowContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Type_name_flowContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_flow(s) } } func (s *Type_name_flowContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_flow(s) } } @@ -23438,13 +23438,13 @@ func (s *Type_name_flowContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_flow() (localctx IType_name_flowContext) { +func (p *YQLParser) Type_name_flow() (localctx IType_name_flowContext) { localctx = NewType_name_flowContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 186, YQLv1Antlr4ParserRULE_type_name_flow) + p.EnterRule(localctx, 186, YQLParserRULE_type_name_flow) p.EnterOuterAlt(localctx, 1) { p.SetState(1775) - p.Match(YQLv1Antlr4ParserFLOW) + p.Match(YQLParserFLOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23452,7 +23452,7 @@ func (p *YQLv1Antlr4Parser) Type_name_flow() (localctx IType_name_flowContext) { } { p.SetState(1776) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23464,7 +23464,7 @@ func (p *YQLv1Antlr4Parser) Type_name_flow() (localctx IType_name_flowContext) { } { p.SetState(1778) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23514,13 +23514,13 @@ type Type_name_dictContext struct { func NewEmptyType_name_dictContext() *Type_name_dictContext { var p = new(Type_name_dictContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_dict + p.RuleIndex = YQLParserRULE_type_name_dict return p } func InitEmptyType_name_dictContext(p *Type_name_dictContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_dict + p.RuleIndex = YQLParserRULE_type_name_dict } func (*Type_name_dictContext) IsType_name_dictContext() {} @@ -23531,7 +23531,7 @@ func NewType_name_dictContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_dict + p.RuleIndex = YQLParserRULE_type_name_dict return p } @@ -23539,11 +23539,11 @@ func NewType_name_dictContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Type_name_dictContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_dictContext) DICT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDICT, 0) + return s.GetToken(YQLParserDICT, 0) } func (s *Type_name_dictContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_dictContext) AllType_name_or_bind() []IType_name_or_bindContext { @@ -23588,11 +23588,11 @@ func (s *Type_name_dictContext) Type_name_or_bind(i int) IType_name_or_bindConte } func (s *Type_name_dictContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Type_name_dictContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_dictContext) GetRuleContext() antlr.RuleContext { @@ -23605,13 +23605,13 @@ func (s *Type_name_dictContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Type_name_dictContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_dict(s) } } func (s *Type_name_dictContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_dict(s) } } @@ -23619,13 +23619,13 @@ func (s *Type_name_dictContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_dict() (localctx IType_name_dictContext) { +func (p *YQLParser) Type_name_dict() (localctx IType_name_dictContext) { localctx = NewType_name_dictContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 188, YQLv1Antlr4ParserRULE_type_name_dict) + p.EnterRule(localctx, 188, YQLParserRULE_type_name_dict) p.EnterOuterAlt(localctx, 1) { p.SetState(1780) - p.Match(YQLv1Antlr4ParserDICT) + p.Match(YQLParserDICT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23633,7 +23633,7 @@ func (p *YQLv1Antlr4Parser) Type_name_dict() (localctx IType_name_dictContext) { } { p.SetState(1781) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23645,7 +23645,7 @@ func (p *YQLv1Antlr4Parser) Type_name_dict() (localctx IType_name_dictContext) { } { p.SetState(1783) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23657,7 +23657,7 @@ func (p *YQLv1Antlr4Parser) Type_name_dict() (localctx IType_name_dictContext) { } { p.SetState(1785) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23705,13 +23705,13 @@ type Type_name_setContext struct { func NewEmptyType_name_setContext() *Type_name_setContext { var p = new(Type_name_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_set + p.RuleIndex = YQLParserRULE_type_name_set return p } func InitEmptyType_name_setContext(p *Type_name_setContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_set + p.RuleIndex = YQLParserRULE_type_name_set } func (*Type_name_setContext) IsType_name_setContext() {} @@ -23722,7 +23722,7 @@ func NewType_name_setContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_set + p.RuleIndex = YQLParserRULE_type_name_set return p } @@ -23730,11 +23730,11 @@ func NewType_name_setContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Type_name_setContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_setContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Type_name_setContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_setContext) Type_name_or_bind() IType_name_or_bindContext { @@ -23754,7 +23754,7 @@ func (s *Type_name_setContext) Type_name_or_bind() IType_name_or_bindContext { } func (s *Type_name_setContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_setContext) GetRuleContext() antlr.RuleContext { @@ -23767,13 +23767,13 @@ func (s *Type_name_setContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Type_name_setContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_set(s) } } func (s *Type_name_setContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_set(s) } } @@ -23781,13 +23781,13 @@ func (s *Type_name_setContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_set() (localctx IType_name_setContext) { +func (p *YQLParser) Type_name_set() (localctx IType_name_setContext) { localctx = NewType_name_setContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 190, YQLv1Antlr4ParserRULE_type_name_set) + p.EnterRule(localctx, 190, YQLParserRULE_type_name_set) p.EnterOuterAlt(localctx, 1) { p.SetState(1787) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23795,7 +23795,7 @@ func (p *YQLv1Antlr4Parser) Type_name_set() (localctx IType_name_setContext) { } { p.SetState(1788) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23807,7 +23807,7 @@ func (p *YQLv1Antlr4Parser) Type_name_set() (localctx IType_name_setContext) { } { p.SetState(1790) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23858,13 +23858,13 @@ type Type_name_enumContext struct { func NewEmptyType_name_enumContext() *Type_name_enumContext { var p = new(Type_name_enumContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_enum + p.RuleIndex = YQLParserRULE_type_name_enum return p } func InitEmptyType_name_enumContext(p *Type_name_enumContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_enum + p.RuleIndex = YQLParserRULE_type_name_enum } func (*Type_name_enumContext) IsType_name_enumContext() {} @@ -23875,7 +23875,7 @@ func NewType_name_enumContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_enum + p.RuleIndex = YQLParserRULE_type_name_enum return p } @@ -23883,11 +23883,11 @@ func NewType_name_enumContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Type_name_enumContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_enumContext) ENUM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserENUM, 0) + return s.GetToken(YQLParserENUM, 0) } func (s *Type_name_enumContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_enumContext) AllType_name_tag() []IType_name_tagContext { @@ -23932,15 +23932,15 @@ func (s *Type_name_enumContext) Type_name_tag(i int) IType_name_tagContext { } func (s *Type_name_enumContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_enumContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Type_name_enumContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Type_name_enumContext) GetRuleContext() antlr.RuleContext { @@ -23953,13 +23953,13 @@ func (s *Type_name_enumContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Type_name_enumContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_enum(s) } } func (s *Type_name_enumContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_enum(s) } } @@ -23967,9 +23967,9 @@ func (s *Type_name_enumContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_enum() (localctx IType_name_enumContext) { +func (p *YQLParser) Type_name_enum() (localctx IType_name_enumContext) { localctx = NewType_name_enumContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 192, YQLv1Antlr4ParserRULE_type_name_enum) + p.EnterRule(localctx, 192, YQLParserRULE_type_name_enum) var _la int var _alt int @@ -23977,7 +23977,7 @@ func (p *YQLv1Antlr4Parser) Type_name_enum() (localctx IType_name_enumContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(1792) - p.Match(YQLv1Antlr4ParserENUM) + p.Match(YQLParserENUM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23985,7 +23985,7 @@ func (p *YQLv1Antlr4Parser) Type_name_enum() (localctx IType_name_enumContext) { } { p.SetState(1793) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24008,7 +24008,7 @@ func (p *YQLv1Antlr4Parser) Type_name_enum() (localctx IType_name_enumContext) { if _alt == 1 { { p.SetState(1795) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24039,10 +24039,10 @@ func (p *YQLv1Antlr4Parser) Type_name_enum() (localctx IType_name_enumContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1802) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24052,7 +24052,7 @@ func (p *YQLv1Antlr4Parser) Type_name_enum() (localctx IType_name_enumContext) { } { p.SetState(1805) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24100,13 +24100,13 @@ type Type_name_resourceContext struct { func NewEmptyType_name_resourceContext() *Type_name_resourceContext { var p = new(Type_name_resourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_resource + p.RuleIndex = YQLParserRULE_type_name_resource return p } func InitEmptyType_name_resourceContext(p *Type_name_resourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_resource + p.RuleIndex = YQLParserRULE_type_name_resource } func (*Type_name_resourceContext) IsType_name_resourceContext() {} @@ -24117,7 +24117,7 @@ func NewType_name_resourceContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_resource + p.RuleIndex = YQLParserRULE_type_name_resource return p } @@ -24125,11 +24125,11 @@ func NewType_name_resourceContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Type_name_resourceContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_resourceContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Type_name_resourceContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_resourceContext) Type_name_tag() IType_name_tagContext { @@ -24149,7 +24149,7 @@ func (s *Type_name_resourceContext) Type_name_tag() IType_name_tagContext { } func (s *Type_name_resourceContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_resourceContext) GetRuleContext() antlr.RuleContext { @@ -24162,13 +24162,13 @@ func (s *Type_name_resourceContext) ToStringTree(ruleNames []string, recog antlr func (s *Type_name_resourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_resource(s) } } func (s *Type_name_resourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_resource(s) } } @@ -24176,13 +24176,13 @@ func (s *Type_name_resourceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_resource() (localctx IType_name_resourceContext) { +func (p *YQLParser) Type_name_resource() (localctx IType_name_resourceContext) { localctx = NewType_name_resourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 194, YQLv1Antlr4ParserRULE_type_name_resource) + p.EnterRule(localctx, 194, YQLParserRULE_type_name_resource) p.EnterOuterAlt(localctx, 1) { p.SetState(1807) - p.Match(YQLv1Antlr4ParserRESOURCE) + p.Match(YQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24190,7 +24190,7 @@ func (p *YQLv1Antlr4Parser) Type_name_resource() (localctx IType_name_resourceCo } { p.SetState(1808) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24202,7 +24202,7 @@ func (p *YQLv1Antlr4Parser) Type_name_resource() (localctx IType_name_resourceCo } { p.SetState(1810) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24252,13 +24252,13 @@ type Type_name_taggedContext struct { func NewEmptyType_name_taggedContext() *Type_name_taggedContext { var p = new(Type_name_taggedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tagged + p.RuleIndex = YQLParserRULE_type_name_tagged return p } func InitEmptyType_name_taggedContext(p *Type_name_taggedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tagged + p.RuleIndex = YQLParserRULE_type_name_tagged } func (*Type_name_taggedContext) IsType_name_taggedContext() {} @@ -24269,7 +24269,7 @@ func NewType_name_taggedContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_tagged + p.RuleIndex = YQLParserRULE_type_name_tagged return p } @@ -24277,11 +24277,11 @@ func NewType_name_taggedContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Type_name_taggedContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_taggedContext) TAGGED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTAGGED, 0) + return s.GetToken(YQLParserTAGGED, 0) } func (s *Type_name_taggedContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_taggedContext) Type_name_or_bind() IType_name_or_bindContext { @@ -24301,7 +24301,7 @@ func (s *Type_name_taggedContext) Type_name_or_bind() IType_name_or_bindContext } func (s *Type_name_taggedContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Type_name_taggedContext) Type_name_tag() IType_name_tagContext { @@ -24321,7 +24321,7 @@ func (s *Type_name_taggedContext) Type_name_tag() IType_name_tagContext { } func (s *Type_name_taggedContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_taggedContext) GetRuleContext() antlr.RuleContext { @@ -24334,13 +24334,13 @@ func (s *Type_name_taggedContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Type_name_taggedContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_tagged(s) } } func (s *Type_name_taggedContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_tagged(s) } } @@ -24348,13 +24348,13 @@ func (s *Type_name_taggedContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_tagged() (localctx IType_name_taggedContext) { +func (p *YQLParser) Type_name_tagged() (localctx IType_name_taggedContext) { localctx = NewType_name_taggedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 196, YQLv1Antlr4ParserRULE_type_name_tagged) + p.EnterRule(localctx, 196, YQLParserRULE_type_name_tagged) p.EnterOuterAlt(localctx, 1) { p.SetState(1812) - p.Match(YQLv1Antlr4ParserTAGGED) + p.Match(YQLParserTAGGED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24362,7 +24362,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tagged() (localctx IType_name_taggedContex } { p.SetState(1813) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24374,7 +24374,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tagged() (localctx IType_name_taggedContex } { p.SetState(1815) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24386,7 +24386,7 @@ func (p *YQLv1Antlr4Parser) Type_name_tagged() (localctx IType_name_taggedContex } { p.SetState(1817) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24442,13 +24442,13 @@ type Type_name_callableContext struct { func NewEmptyType_name_callableContext() *Type_name_callableContext { var p = new(Type_name_callableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_callable + p.RuleIndex = YQLParserRULE_type_name_callable return p } func InitEmptyType_name_callableContext(p *Type_name_callableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_callable + p.RuleIndex = YQLParserRULE_type_name_callable } func (*Type_name_callableContext) IsType_name_callableContext() {} @@ -24459,7 +24459,7 @@ func NewType_name_callableContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_callable + p.RuleIndex = YQLParserRULE_type_name_callable return p } @@ -24467,23 +24467,23 @@ func NewType_name_callableContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Type_name_callableContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_callableContext) CALLABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCALLABLE, 0) + return s.GetToken(YQLParserCALLABLE, 0) } func (s *Type_name_callableContext) LESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLESS, 0) + return s.GetToken(YQLParserLESS, 0) } func (s *Type_name_callableContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Type_name_callableContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Type_name_callableContext) ARROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserARROW, 0) + return s.GetToken(YQLParserARROW, 0) } func (s *Type_name_callableContext) Type_name_or_bind() IType_name_or_bindContext { @@ -24503,7 +24503,7 @@ func (s *Type_name_callableContext) Type_name_or_bind() IType_name_or_bindContex } func (s *Type_name_callableContext) GREATER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGREATER, 0) + return s.GetToken(YQLParserGREATER, 0) } func (s *Type_name_callableContext) AllCallable_arg_list() []ICallable_arg_listContext { @@ -24548,15 +24548,15 @@ func (s *Type_name_callableContext) Callable_arg_list(i int) ICallable_arg_listC } func (s *Type_name_callableContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Type_name_callableContext) LBRACE_SQUARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_SQUARE, 0) + return s.GetToken(YQLParserLBRACE_SQUARE, 0) } func (s *Type_name_callableContext) RBRACE_SQUARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_SQUARE, 0) + return s.GetToken(YQLParserRBRACE_SQUARE, 0) } func (s *Type_name_callableContext) GetRuleContext() antlr.RuleContext { @@ -24569,13 +24569,13 @@ func (s *Type_name_callableContext) ToStringTree(ruleNames []string, recog antlr func (s *Type_name_callableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_callable(s) } } func (s *Type_name_callableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_callable(s) } } @@ -24583,15 +24583,15 @@ func (s *Type_name_callableContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableContext) { +func (p *YQLParser) Type_name_callable() (localctx IType_name_callableContext) { localctx = NewType_name_callableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 198, YQLv1Antlr4ParserRULE_type_name_callable) + p.EnterRule(localctx, 198, YQLParserRULE_type_name_callable) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1819) - p.Match(YQLv1Antlr4ParserCALLABLE) + p.Match(YQLParserCALLABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24599,7 +24599,7 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo } { p.SetState(1820) - p.Match(YQLv1Antlr4ParserLESS) + p.Match(YQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24607,7 +24607,7 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo } { p.SetState(1821) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24636,10 +24636,10 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(1825) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24655,10 +24655,10 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLBRACE_SQUARE { + if _la == YQLParserLBRACE_SQUARE { { p.SetState(1828) - p.Match(YQLv1Antlr4ParserLBRACE_SQUARE) + p.Match(YQLParserLBRACE_SQUARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24670,7 +24670,7 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo } { p.SetState(1830) - p.Match(YQLv1Antlr4ParserRBRACE_SQUARE) + p.Match(YQLParserRBRACE_SQUARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24680,7 +24680,7 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo } { p.SetState(1834) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24688,7 +24688,7 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo } { p.SetState(1835) - p.Match(YQLv1Antlr4ParserARROW) + p.Match(YQLParserARROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24700,7 +24700,7 @@ func (p *YQLv1Antlr4Parser) Type_name_callable() (localctx IType_name_callableCo } { p.SetState(1837) - p.Match(YQLv1Antlr4ParserGREATER) + p.Match(YQLParserGREATER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24759,13 +24759,13 @@ type Type_name_compositeContext struct { func NewEmptyType_name_compositeContext() *Type_name_compositeContext { var p = new(Type_name_compositeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_composite + p.RuleIndex = YQLParserRULE_type_name_composite return p } func InitEmptyType_name_compositeContext(p *Type_name_compositeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_composite + p.RuleIndex = YQLParserRULE_type_name_composite } func (*Type_name_compositeContext) IsType_name_compositeContext() {} @@ -24776,7 +24776,7 @@ func NewType_name_compositeContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_composite + p.RuleIndex = YQLParserRULE_type_name_composite return p } @@ -24992,11 +24992,11 @@ func (s *Type_name_compositeContext) Type_name_callable() IType_name_callableCon } func (s *Type_name_compositeContext) AllQUESTION() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserQUESTION) + return s.GetTokens(YQLParserQUESTION) } func (s *Type_name_compositeContext) QUESTION(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUESTION, i) + return s.GetToken(YQLParserQUESTION, i) } func (s *Type_name_compositeContext) GetRuleContext() antlr.RuleContext { @@ -25009,13 +25009,13 @@ func (s *Type_name_compositeContext) ToStringTree(ruleNames []string, recog antl func (s *Type_name_compositeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_composite(s) } } func (s *Type_name_compositeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_composite(s) } } @@ -25023,9 +25023,9 @@ func (s *Type_name_compositeContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Type_name_composite() (localctx IType_name_compositeContext) { +func (p *YQLParser) Type_name_composite() (localctx IType_name_compositeContext) { localctx = NewType_name_compositeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 200, YQLv1Antlr4ParserRULE_type_name_composite) + p.EnterRule(localctx, 200, YQLParserRULE_type_name_composite) var _la int p.EnterOuterAlt(localctx, 1) @@ -25036,91 +25036,91 @@ func (p *YQLv1Antlr4Parser) Type_name_composite() (localctx IType_name_composite } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserOPTIONAL: + case YQLParserOPTIONAL: { p.SetState(1839) p.Type_name_optional() } - case YQLv1Antlr4ParserTUPLE: + case YQLParserTUPLE: { p.SetState(1840) p.Type_name_tuple() } - case YQLv1Antlr4ParserSTRUCT: + case YQLParserSTRUCT: { p.SetState(1841) p.Type_name_struct() } - case YQLv1Antlr4ParserVARIANT: + case YQLParserVARIANT: { p.SetState(1842) p.Type_name_variant() } - case YQLv1Antlr4ParserLIST: + case YQLParserLIST: { p.SetState(1843) p.Type_name_list() } - case YQLv1Antlr4ParserSTREAM: + case YQLParserSTREAM: { p.SetState(1844) p.Type_name_stream() } - case YQLv1Antlr4ParserFLOW: + case YQLParserFLOW: { p.SetState(1845) p.Type_name_flow() } - case YQLv1Antlr4ParserDICT: + case YQLParserDICT: { p.SetState(1846) p.Type_name_dict() } - case YQLv1Antlr4ParserSET: + case YQLParserSET: { p.SetState(1847) p.Type_name_set() } - case YQLv1Antlr4ParserENUM: + case YQLParserENUM: { p.SetState(1848) p.Type_name_enum() } - case YQLv1Antlr4ParserRESOURCE: + case YQLParserRESOURCE: { p.SetState(1849) p.Type_name_resource() } - case YQLv1Antlr4ParserTAGGED: + case YQLParserTAGGED: { p.SetState(1850) p.Type_name_tagged() } - case YQLv1Antlr4ParserCALLABLE: + case YQLParserCALLABLE: { p.SetState(1851) p.Type_name_callable() @@ -25140,10 +25140,10 @@ func (p *YQLv1Antlr4Parser) Type_name_composite() (localctx IType_name_composite _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserQUESTION { + for _la == YQLParserQUESTION { { p.SetState(1854) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25201,13 +25201,13 @@ type Type_nameContext struct { func NewEmptyType_nameContext() *Type_nameContext { var p = new(Type_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name + p.RuleIndex = YQLParserRULE_type_name return p } func InitEmptyType_nameContext(p *Type_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name + p.RuleIndex = YQLParserRULE_type_name } func (*Type_nameContext) IsType_nameContext() {} @@ -25218,7 +25218,7 @@ func NewType_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name + p.RuleIndex = YQLParserRULE_type_name return p } @@ -25274,11 +25274,11 @@ func (s *Type_nameContext) Type_name_simple() IType_name_simpleContext { } func (s *Type_nameContext) AllQUESTION() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserQUESTION) + return s.GetTokens(YQLParserQUESTION) } func (s *Type_nameContext) QUESTION(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUESTION, i) + return s.GetToken(YQLParserQUESTION, i) } func (s *Type_nameContext) GetRuleContext() antlr.RuleContext { @@ -25291,13 +25291,13 @@ func (s *Type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name(s) } } func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name(s) } } @@ -25305,9 +25305,9 @@ func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name() (localctx IType_nameContext) { +func (p *YQLParser) Type_name() (localctx IType_nameContext) { localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 202, YQLv1Antlr4ParserRULE_type_name) + p.EnterRule(localctx, 202, YQLParserRULE_type_name) var _la int p.SetState(1871) @@ -25317,7 +25317,7 @@ func (p *YQLv1Antlr4Parser) Type_name() (localctx IType_nameContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserVARIANT: + case YQLParserCALLABLE, YQLParserDICT, YQLParserENUM, YQLParserFLOW, YQLParserLIST, YQLParserOPTIONAL, YQLParserRESOURCE, YQLParserSET, YQLParserSTREAM, YQLParserSTRUCT, YQLParserTAGGED, YQLParserTUPLE, YQLParserVARIANT: p.EnterOuterAlt(localctx, 1) { p.SetState(1860) @@ -25325,7 +25325,7 @@ func (p *YQLv1Antlr4Parser) Type_name() (localctx IType_nameContext) { } - case YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserDECIMAL, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 2) p.SetState(1863) p.GetErrorHandler().Sync(p) @@ -25334,14 +25334,14 @@ func (p *YQLv1Antlr4Parser) Type_name() (localctx IType_nameContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDECIMAL: + case YQLParserDECIMAL: { p.SetState(1861) p.Type_name_decimal() } - case YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(1862) p.Type_name_simple() @@ -25361,10 +25361,10 @@ func (p *YQLv1Antlr4Parser) Type_name() (localctx IType_nameContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserQUESTION { + for _la == YQLParserQUESTION { { p.SetState(1865) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25425,13 +25425,13 @@ type Type_name_or_bindContext struct { func NewEmptyType_name_or_bindContext() *Type_name_or_bindContext { var p = new(Type_name_or_bindContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_or_bind + p.RuleIndex = YQLParserRULE_type_name_or_bind return p } func InitEmptyType_name_or_bindContext(p *Type_name_or_bindContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_or_bind + p.RuleIndex = YQLParserRULE_type_name_or_bind } func (*Type_name_or_bindContext) IsType_name_or_bindContext() {} @@ -25442,7 +25442,7 @@ func NewType_name_or_bindContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_name_or_bind + p.RuleIndex = YQLParserRULE_type_name_or_bind return p } @@ -25491,13 +25491,13 @@ func (s *Type_name_or_bindContext) ToStringTree(ruleNames []string, recog antlr. func (s *Type_name_or_bindContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_name_or_bind(s) } } func (s *Type_name_or_bindContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_name_or_bind(s) } } @@ -25505,9 +25505,9 @@ func (s *Type_name_or_bindContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_name_or_bind() (localctx IType_name_or_bindContext) { +func (p *YQLParser) Type_name_or_bind() (localctx IType_name_or_bindContext) { localctx = NewType_name_or_bindContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 204, YQLv1Antlr4ParserRULE_type_name_or_bind) + p.EnterRule(localctx, 204, YQLParserRULE_type_name_or_bind) p.SetState(1875) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -25515,7 +25515,7 @@ func (p *YQLv1Antlr4Parser) Type_name_or_bind() (localctx IType_name_or_bindCont } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserCALLABLE, YQLParserDECIMAL, YQLParserDICT, YQLParserENUM, YQLParserFLOW, YQLParserLIST, YQLParserOPTIONAL, YQLParserRESOURCE, YQLParserSET, YQLParserSTREAM, YQLParserSTRUCT, YQLParserTAGGED, YQLParserTUPLE, YQLParserVARIANT, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(1873) @@ -25523,7 +25523,7 @@ func (p *YQLv1Antlr4Parser) Type_name_or_bind() (localctx IType_name_or_bindCont } - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 2) { p.SetState(1874) @@ -25574,13 +25574,13 @@ type Value_constructor_literalContext struct { func NewEmptyValue_constructor_literalContext() *Value_constructor_literalContext { var p = new(Value_constructor_literalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_value_constructor_literal + p.RuleIndex = YQLParserRULE_value_constructor_literal return p } func InitEmptyValue_constructor_literalContext(p *Value_constructor_literalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_value_constructor_literal + p.RuleIndex = YQLParserRULE_value_constructor_literal } func (*Value_constructor_literalContext) IsValue_constructor_literalContext() {} @@ -25591,7 +25591,7 @@ func NewValue_constructor_literalContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_value_constructor_literal + p.RuleIndex = YQLParserRULE_value_constructor_literal return p } @@ -25599,7 +25599,7 @@ func NewValue_constructor_literalContext(parser antlr.Parser, parent antlr.Parse func (s *Value_constructor_literalContext) GetParser() antlr.Parser { return s.parser } func (s *Value_constructor_literalContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Value_constructor_literalContext) GetRuleContext() antlr.RuleContext { @@ -25612,13 +25612,13 @@ func (s *Value_constructor_literalContext) ToStringTree(ruleNames []string, reco func (s *Value_constructor_literalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterValue_constructor_literal(s) } } func (s *Value_constructor_literalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitValue_constructor_literal(s) } } @@ -25626,13 +25626,13 @@ func (s *Value_constructor_literalContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Value_constructor_literal() (localctx IValue_constructor_literalContext) { +func (p *YQLParser) Value_constructor_literal() (localctx IValue_constructor_literalContext) { localctx = NewValue_constructor_literalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 206, YQLv1Antlr4ParserRULE_value_constructor_literal) + p.EnterRule(localctx, 206, YQLParserRULE_value_constructor_literal) p.EnterOuterAlt(localctx, 1) { p.SetState(1877) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25685,13 +25685,13 @@ type Value_constructorContext struct { func NewEmptyValue_constructorContext() *Value_constructorContext { var p = new(Value_constructorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_value_constructor + p.RuleIndex = YQLParserRULE_value_constructor return p } func InitEmptyValue_constructorContext(p *Value_constructorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_value_constructor + p.RuleIndex = YQLParserRULE_value_constructor } func (*Value_constructorContext) IsValue_constructorContext() {} @@ -25702,7 +25702,7 @@ func NewValue_constructorContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_value_constructor + p.RuleIndex = YQLParserRULE_value_constructor return p } @@ -25710,11 +25710,11 @@ func NewValue_constructorContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Value_constructorContext) GetParser() antlr.Parser { return s.parser } func (s *Value_constructorContext) VARIANT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVARIANT, 0) + return s.GetToken(YQLParserVARIANT, 0) } func (s *Value_constructorContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Value_constructorContext) AllExpr() []IExprContext { @@ -25759,23 +25759,23 @@ func (s *Value_constructorContext) Expr(i int) IExprContext { } func (s *Value_constructorContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Value_constructorContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Value_constructorContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Value_constructorContext) ENUM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserENUM, 0) + return s.GetToken(YQLParserENUM, 0) } func (s *Value_constructorContext) CALLABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCALLABLE, 0) + return s.GetToken(YQLParserCALLABLE, 0) } func (s *Value_constructorContext) GetRuleContext() antlr.RuleContext { @@ -25788,13 +25788,13 @@ func (s *Value_constructorContext) ToStringTree(ruleNames []string, recog antlr. func (s *Value_constructorContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterValue_constructor(s) } } func (s *Value_constructorContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitValue_constructor(s) } } @@ -25802,9 +25802,9 @@ func (s *Value_constructorContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorContext) { +func (p *YQLParser) Value_constructor() (localctx IValue_constructorContext) { localctx = NewValue_constructorContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 208, YQLv1Antlr4ParserRULE_value_constructor) + p.EnterRule(localctx, 208, YQLParserRULE_value_constructor) p.SetState(1902) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -25812,11 +25812,11 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserVARIANT: + case YQLParserVARIANT: p.EnterOuterAlt(localctx, 1) { p.SetState(1879) - p.Match(YQLv1Antlr4ParserVARIANT) + p.Match(YQLParserVARIANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25824,7 +25824,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1880) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25836,7 +25836,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1882) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25848,7 +25848,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1884) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25860,7 +25860,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1886) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25868,11 +25868,11 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } - case YQLv1Antlr4ParserENUM: + case YQLParserENUM: p.EnterOuterAlt(localctx, 2) { p.SetState(1888) - p.Match(YQLv1Antlr4ParserENUM) + p.Match(YQLParserENUM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25880,7 +25880,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1889) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25892,7 +25892,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1891) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25904,7 +25904,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1893) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25912,11 +25912,11 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } - case YQLv1Antlr4ParserCALLABLE: + case YQLParserCALLABLE: p.EnterOuterAlt(localctx, 3) { p.SetState(1895) - p.Match(YQLv1Antlr4ParserCALLABLE) + p.Match(YQLParserCALLABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25924,7 +25924,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1896) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25936,7 +25936,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1898) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25948,7 +25948,7 @@ func (p *YQLv1Antlr4Parser) Value_constructor() (localctx IValue_constructorCont } { p.SetState(1900) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26004,13 +26004,13 @@ type Declare_stmtContext struct { func NewEmptyDeclare_stmtContext() *Declare_stmtContext { var p = new(Declare_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_declare_stmt + p.RuleIndex = YQLParserRULE_declare_stmt return p } func InitEmptyDeclare_stmtContext(p *Declare_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_declare_stmt + p.RuleIndex = YQLParserRULE_declare_stmt } func (*Declare_stmtContext) IsDeclare_stmtContext() {} @@ -26021,7 +26021,7 @@ func NewDeclare_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_declare_stmt + p.RuleIndex = YQLParserRULE_declare_stmt return p } @@ -26029,7 +26029,7 @@ func NewDeclare_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Declare_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Declare_stmtContext) DECLARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDECLARE, 0) + return s.GetToken(YQLParserDECLARE, 0) } func (s *Declare_stmtContext) Bind_parameter() IBind_parameterContext { @@ -26049,7 +26049,7 @@ func (s *Declare_stmtContext) Bind_parameter() IBind_parameterContext { } func (s *Declare_stmtContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Declare_stmtContext) Type_name() IType_nameContext { @@ -26069,7 +26069,7 @@ func (s *Declare_stmtContext) Type_name() IType_nameContext { } func (s *Declare_stmtContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Declare_stmtContext) Literal_value() ILiteral_valueContext { @@ -26098,13 +26098,13 @@ func (s *Declare_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Declare_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDeclare_stmt(s) } } func (s *Declare_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDeclare_stmt(s) } } @@ -26112,15 +26112,15 @@ func (s *Declare_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Declare_stmt() (localctx IDeclare_stmtContext) { +func (p *YQLParser) Declare_stmt() (localctx IDeclare_stmtContext) { localctx = NewDeclare_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 210, YQLv1Antlr4ParserRULE_declare_stmt) + p.EnterRule(localctx, 210, YQLParserRULE_declare_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1904) - p.Match(YQLv1Antlr4ParserDECLARE) + p.Match(YQLParserDECLARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26132,7 +26132,7 @@ func (p *YQLv1Antlr4Parser) Declare_stmt() (localctx IDeclare_stmtContext) { } { p.SetState(1906) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26150,10 +26150,10 @@ func (p *YQLv1Antlr4Parser) Declare_stmt() (localctx IDeclare_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEQUALS { + if _la == YQLParserEQUALS { { p.SetState(1908) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26207,13 +26207,13 @@ type Module_pathContext struct { func NewEmptyModule_pathContext() *Module_pathContext { var p = new(Module_pathContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_module_path + p.RuleIndex = YQLParserRULE_module_path return p } func InitEmptyModule_pathContext(p *Module_pathContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_module_path + p.RuleIndex = YQLParserRULE_module_path } func (*Module_pathContext) IsModule_pathContext() {} @@ -26224,7 +26224,7 @@ func NewModule_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_module_path + p.RuleIndex = YQLParserRULE_module_path return p } @@ -26273,11 +26273,11 @@ func (s *Module_pathContext) An_id(i int) IAn_idContext { } func (s *Module_pathContext) AllDOT() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserDOT) + return s.GetTokens(YQLParserDOT) } func (s *Module_pathContext) DOT(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, i) + return s.GetToken(YQLParserDOT, i) } func (s *Module_pathContext) GetRuleContext() antlr.RuleContext { @@ -26290,13 +26290,13 @@ func (s *Module_pathContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Module_pathContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterModule_path(s) } } func (s *Module_pathContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitModule_path(s) } } @@ -26304,9 +26304,9 @@ func (s *Module_pathContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Module_path() (localctx IModule_pathContext) { +func (p *YQLParser) Module_path() (localctx IModule_pathContext) { localctx = NewModule_pathContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 212, YQLv1Antlr4ParserRULE_module_path) + p.EnterRule(localctx, 212, YQLParserRULE_module_path) var _la int p.EnterOuterAlt(localctx, 1) @@ -26318,10 +26318,10 @@ func (p *YQLv1Antlr4Parser) Module_path() (localctx IModule_pathContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDOT { + if _la == YQLParserDOT { { p.SetState(1912) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26341,10 +26341,10 @@ func (p *YQLv1Antlr4Parser) Module_path() (localctx IModule_pathContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserDOT { + for _la == YQLParserDOT { { p.SetState(1916) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26405,13 +26405,13 @@ type Import_stmtContext struct { func NewEmptyImport_stmtContext() *Import_stmtContext { var p = new(Import_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_import_stmt + p.RuleIndex = YQLParserRULE_import_stmt return p } func InitEmptyImport_stmtContext(p *Import_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_import_stmt + p.RuleIndex = YQLParserRULE_import_stmt } func (*Import_stmtContext) IsImport_stmtContext() {} @@ -26422,7 +26422,7 @@ func NewImport_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_import_stmt + p.RuleIndex = YQLParserRULE_import_stmt return p } @@ -26430,7 +26430,7 @@ func NewImport_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Import_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Import_stmtContext) IMPORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIMPORT, 0) + return s.GetToken(YQLParserIMPORT, 0) } func (s *Import_stmtContext) Module_path() IModule_pathContext { @@ -26450,7 +26450,7 @@ func (s *Import_stmtContext) Module_path() IModule_pathContext { } func (s *Import_stmtContext) SYMBOLS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYMBOLS, 0) + return s.GetToken(YQLParserSYMBOLS, 0) } func (s *Import_stmtContext) Named_bind_parameter_list() INamed_bind_parameter_listContext { @@ -26479,13 +26479,13 @@ func (s *Import_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Import_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterImport_stmt(s) } } func (s *Import_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitImport_stmt(s) } } @@ -26493,13 +26493,13 @@ func (s *Import_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Import_stmt() (localctx IImport_stmtContext) { +func (p *YQLParser) Import_stmt() (localctx IImport_stmtContext) { localctx = NewImport_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 214, YQLv1Antlr4ParserRULE_import_stmt) + p.EnterRule(localctx, 214, YQLParserRULE_import_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1923) - p.Match(YQLv1Antlr4ParserIMPORT) + p.Match(YQLParserIMPORT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26511,7 +26511,7 @@ func (p *YQLv1Antlr4Parser) Import_stmt() (localctx IImport_stmtContext) { } { p.SetState(1925) - p.Match(YQLv1Antlr4ParserSYMBOLS) + p.Match(YQLParserSYMBOLS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26561,13 +26561,13 @@ type Export_stmtContext struct { func NewEmptyExport_stmtContext() *Export_stmtContext { var p = new(Export_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_export_stmt + p.RuleIndex = YQLParserRULE_export_stmt return p } func InitEmptyExport_stmtContext(p *Export_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_export_stmt + p.RuleIndex = YQLParserRULE_export_stmt } func (*Export_stmtContext) IsExport_stmtContext() {} @@ -26578,7 +26578,7 @@ func NewExport_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_export_stmt + p.RuleIndex = YQLParserRULE_export_stmt return p } @@ -26586,7 +26586,7 @@ func NewExport_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Export_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Export_stmtContext) EXPORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXPORT, 0) + return s.GetToken(YQLParserEXPORT, 0) } func (s *Export_stmtContext) Bind_parameter_list() IBind_parameter_listContext { @@ -26615,13 +26615,13 @@ func (s *Export_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Export_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExport_stmt(s) } } func (s *Export_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExport_stmt(s) } } @@ -26629,13 +26629,13 @@ func (s *Export_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Export_stmt() (localctx IExport_stmtContext) { +func (p *YQLParser) Export_stmt() (localctx IExport_stmtContext) { localctx = NewExport_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 216, YQLv1Antlr4ParserRULE_export_stmt) + p.EnterRule(localctx, 216, YQLParserRULE_export_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1928) - p.Match(YQLv1Antlr4ParserEXPORT) + p.Match(YQLParserEXPORT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26688,13 +26688,13 @@ type Call_actionContext struct { func NewEmptyCall_actionContext() *Call_actionContext { var p = new(Call_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_call_action + p.RuleIndex = YQLParserRULE_call_action return p } func InitEmptyCall_actionContext(p *Call_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_call_action + p.RuleIndex = YQLParserRULE_call_action } func (*Call_actionContext) IsCall_actionContext() {} @@ -26705,7 +26705,7 @@ func NewCall_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_call_action + p.RuleIndex = YQLParserRULE_call_action return p } @@ -26713,11 +26713,11 @@ func NewCall_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Call_actionContext) GetParser() antlr.Parser { return s.parser } func (s *Call_actionContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Call_actionContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Call_actionContext) Bind_parameter() IBind_parameterContext { @@ -26737,7 +26737,7 @@ func (s *Call_actionContext) Bind_parameter() IBind_parameterContext { } func (s *Call_actionContext) EMPTY_ACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY_ACTION, 0) + return s.GetToken(YQLParserEMPTY_ACTION, 0) } func (s *Call_actionContext) Expr_list() IExpr_listContext { @@ -26766,13 +26766,13 @@ func (s *Call_actionContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Call_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCall_action(s) } } func (s *Call_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCall_action(s) } } @@ -26780,9 +26780,9 @@ func (s *Call_actionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Call_action() (localctx ICall_actionContext) { +func (p *YQLParser) Call_action() (localctx ICall_actionContext) { localctx = NewCall_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 218, YQLv1Antlr4ParserRULE_call_action) + p.EnterRule(localctx, 218, YQLParserRULE_call_action) var _la int p.EnterOuterAlt(localctx, 1) @@ -26793,17 +26793,17 @@ func (p *YQLv1Antlr4Parser) Call_action() (localctx ICall_actionContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: { p.SetState(1931) p.Bind_parameter() } - case YQLv1Antlr4ParserEMPTY_ACTION: + case YQLParserEMPTY_ACTION: { p.SetState(1932) - p.Match(YQLv1Antlr4ParserEMPTY_ACTION) + p.Match(YQLParserEMPTY_ACTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26818,7 +26818,7 @@ func (p *YQLv1Antlr4Parser) Call_action() (localctx ICall_actionContext) { } { p.SetState(1935) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26841,7 +26841,7 @@ func (p *YQLv1Antlr4Parser) Call_action() (localctx ICall_actionContext) { } { p.SetState(1939) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26889,13 +26889,13 @@ type Inline_actionContext struct { func NewEmptyInline_actionContext() *Inline_actionContext { var p = new(Inline_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_inline_action + p.RuleIndex = YQLParserRULE_inline_action return p } func InitEmptyInline_actionContext(p *Inline_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_inline_action + p.RuleIndex = YQLParserRULE_inline_action } func (*Inline_actionContext) IsInline_actionContext() {} @@ -26906,7 +26906,7 @@ func NewInline_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_inline_action + p.RuleIndex = YQLParserRULE_inline_action return p } @@ -26914,7 +26914,7 @@ func NewInline_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Inline_actionContext) GetParser() antlr.Parser { return s.parser } func (s *Inline_actionContext) BEGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBEGIN, 0) + return s.GetToken(YQLParserBEGIN, 0) } func (s *Inline_actionContext) Define_action_or_subquery_body() IDefine_action_or_subquery_bodyContext { @@ -26934,11 +26934,11 @@ func (s *Inline_actionContext) Define_action_or_subquery_body() IDefine_action_o } func (s *Inline_actionContext) END() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEND, 0) + return s.GetToken(YQLParserEND, 0) } func (s *Inline_actionContext) DO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDO, 0) + return s.GetToken(YQLParserDO, 0) } func (s *Inline_actionContext) GetRuleContext() antlr.RuleContext { @@ -26951,13 +26951,13 @@ func (s *Inline_actionContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Inline_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInline_action(s) } } func (s *Inline_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInline_action(s) } } @@ -26965,13 +26965,13 @@ func (s *Inline_actionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Inline_action() (localctx IInline_actionContext) { +func (p *YQLParser) Inline_action() (localctx IInline_actionContext) { localctx = NewInline_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 220, YQLv1Antlr4ParserRULE_inline_action) + p.EnterRule(localctx, 220, YQLParserRULE_inline_action) p.EnterOuterAlt(localctx, 1) { p.SetState(1941) - p.Match(YQLv1Antlr4ParserBEGIN) + p.Match(YQLParserBEGIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26983,7 +26983,7 @@ func (p *YQLv1Antlr4Parser) Inline_action() (localctx IInline_actionContext) { } { p.SetState(1943) - p.Match(YQLv1Antlr4ParserEND) + p.Match(YQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26991,7 +26991,7 @@ func (p *YQLv1Antlr4Parser) Inline_action() (localctx IInline_actionContext) { } { p.SetState(1944) - p.Match(YQLv1Antlr4ParserDO) + p.Match(YQLParserDO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27038,13 +27038,13 @@ type Do_stmtContext struct { func NewEmptyDo_stmtContext() *Do_stmtContext { var p = new(Do_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_do_stmt + p.RuleIndex = YQLParserRULE_do_stmt return p } func InitEmptyDo_stmtContext(p *Do_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_do_stmt + p.RuleIndex = YQLParserRULE_do_stmt } func (*Do_stmtContext) IsDo_stmtContext() {} @@ -27055,7 +27055,7 @@ func NewDo_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_do_stmt + p.RuleIndex = YQLParserRULE_do_stmt return p } @@ -27063,7 +27063,7 @@ func NewDo_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *Do_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Do_stmtContext) DO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDO, 0) + return s.GetToken(YQLParserDO, 0) } func (s *Do_stmtContext) Call_action() ICall_actionContext { @@ -27108,13 +27108,13 @@ func (s *Do_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *Do_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDo_stmt(s) } } func (s *Do_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDo_stmt(s) } } @@ -27122,13 +27122,13 @@ func (s *Do_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Do_stmt() (localctx IDo_stmtContext) { +func (p *YQLParser) Do_stmt() (localctx IDo_stmtContext) { localctx = NewDo_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 222, YQLv1Antlr4ParserRULE_do_stmt) + p.EnterRule(localctx, 222, YQLParserRULE_do_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1946) - p.Match(YQLv1Antlr4ParserDO) + p.Match(YQLParserDO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27141,14 +27141,14 @@ func (p *YQLv1Antlr4Parser) Do_stmt() (localctx IDo_stmtContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDOLLAR, YQLv1Antlr4ParserEMPTY_ACTION: + case YQLParserDOLLAR, YQLParserEMPTY_ACTION: { p.SetState(1947) p.Call_action() } - case YQLv1Antlr4ParserBEGIN: + case YQLParserBEGIN: { p.SetState(1948) p.Inline_action() @@ -27208,13 +27208,13 @@ type Pragma_stmtContext struct { func NewEmptyPragma_stmtContext() *Pragma_stmtContext { var p = new(Pragma_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pragma_stmt + p.RuleIndex = YQLParserRULE_pragma_stmt return p } func InitEmptyPragma_stmtContext(p *Pragma_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pragma_stmt + p.RuleIndex = YQLParserRULE_pragma_stmt } func (*Pragma_stmtContext) IsPragma_stmtContext() {} @@ -27225,7 +27225,7 @@ func NewPragma_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_pragma_stmt + p.RuleIndex = YQLParserRULE_pragma_stmt return p } @@ -27233,7 +27233,7 @@ func NewPragma_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Pragma_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Pragma_stmtContext) PRAGMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRAGMA, 0) + return s.GetToken(YQLParserPRAGMA, 0) } func (s *Pragma_stmtContext) Opt_id_prefix_or_type() IOpt_id_prefix_or_typeContext { @@ -27269,7 +27269,7 @@ func (s *Pragma_stmtContext) An_id() IAn_idContext { } func (s *Pragma_stmtContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Pragma_stmtContext) AllPragma_value() []IPragma_valueContext { @@ -27314,19 +27314,19 @@ func (s *Pragma_stmtContext) Pragma_value(i int) IPragma_valueContext { } func (s *Pragma_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Pragma_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Pragma_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Pragma_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Pragma_stmtContext) GetRuleContext() antlr.RuleContext { @@ -27339,13 +27339,13 @@ func (s *Pragma_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Pragma_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPragma_stmt(s) } } func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPragma_stmt(s) } } @@ -27353,15 +27353,15 @@ func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Pragma_stmt() (localctx IPragma_stmtContext) { +func (p *YQLParser) Pragma_stmt() (localctx IPragma_stmtContext) { localctx = NewPragma_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 224, YQLv1Antlr4ParserRULE_pragma_stmt) + p.EnterRule(localctx, 224, YQLParserRULE_pragma_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1951) - p.Match(YQLv1Antlr4ParserPRAGMA) + p.Match(YQLParserPRAGMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27381,10 +27381,10 @@ func (p *YQLv1Antlr4Parser) Pragma_stmt() (localctx IPragma_stmtContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserEQUALS: + case YQLParserEQUALS: { p.SetState(1954) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27396,10 +27396,10 @@ func (p *YQLv1Antlr4Parser) Pragma_stmt() (localctx IPragma_stmtContext) { } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: { p.SetState(1956) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27417,10 +27417,10 @@ func (p *YQLv1Antlr4Parser) Pragma_stmt() (localctx IPragma_stmtContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(1958) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27441,7 +27441,7 @@ func (p *YQLv1Antlr4Parser) Pragma_stmt() (localctx IPragma_stmtContext) { } { p.SetState(1965) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27449,7 +27449,7 @@ func (p *YQLv1Antlr4Parser) Pragma_stmt() (localctx IPragma_stmtContext) { } - case YQLv1Antlr4ParserEOF, YQLv1Antlr4ParserSEMICOLON, YQLv1Antlr4ParserEND: + case YQLParserEOF, YQLParserSEMICOLON, YQLParserEND: @@ -27498,13 +27498,13 @@ type Pragma_valueContext struct { func NewEmptyPragma_valueContext() *Pragma_valueContext { var p = new(Pragma_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pragma_value + p.RuleIndex = YQLParserRULE_pragma_value return p } func InitEmptyPragma_valueContext(p *Pragma_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_pragma_value + p.RuleIndex = YQLParserRULE_pragma_value } func (*Pragma_valueContext) IsPragma_valueContext() {} @@ -27515,7 +27515,7 @@ func NewPragma_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_pragma_value + p.RuleIndex = YQLParserRULE_pragma_value return p } @@ -27555,7 +27555,7 @@ func (s *Pragma_valueContext) Id() IIdContext { } func (s *Pragma_valueContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Pragma_valueContext) Bool_value() IBool_valueContext { @@ -27600,13 +27600,13 @@ func (s *Pragma_valueContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Pragma_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPragma_value(s) } } func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPragma_value(s) } } @@ -27614,9 +27614,9 @@ func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Pragma_value() (localctx IPragma_valueContext) { +func (p *YQLParser) Pragma_value() (localctx IPragma_valueContext) { localctx = NewPragma_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 226, YQLv1Antlr4ParserRULE_pragma_value) + p.EnterRule(localctx, 226, YQLParserRULE_pragma_value) p.SetState(1974) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -27624,7 +27624,7 @@ func (p *YQLv1Antlr4Parser) Pragma_value() (localctx IPragma_valueContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserPLUS, YQLv1Antlr4ParserMINUS, YQLv1Antlr4ParserDIGITS, YQLv1Antlr4ParserINTEGER_VALUE, YQLv1Antlr4ParserREAL: + case YQLParserPLUS, YQLParserMINUS, YQLParserDIGITS, YQLParserINTEGER_VALUE, YQLParserREAL: p.EnterOuterAlt(localctx, 1) { p.SetState(1969) @@ -27632,7 +27632,7 @@ func (p *YQLv1Antlr4Parser) Pragma_value() (localctx IPragma_valueContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 2) { p.SetState(1970) @@ -27640,11 +27640,11 @@ func (p *YQLv1Antlr4Parser) Pragma_value() (localctx IPragma_valueContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 3) { p.SetState(1971) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27652,7 +27652,7 @@ func (p *YQLv1Antlr4Parser) Pragma_value() (localctx IPragma_valueContext) { } - case YQLv1Antlr4ParserFALSE, YQLv1Antlr4ParserTRUE: + case YQLParserFALSE, YQLParserTRUE: p.EnterOuterAlt(localctx, 4) { p.SetState(1972) @@ -27660,7 +27660,7 @@ func (p *YQLv1Antlr4Parser) Pragma_value() (localctx IPragma_valueContext) { } - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 5) { p.SetState(1973) @@ -27713,13 +27713,13 @@ type Sort_specificationContext struct { func NewEmptySort_specificationContext() *Sort_specificationContext { var p = new(Sort_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sort_specification + p.RuleIndex = YQLParserRULE_sort_specification return p } func InitEmptySort_specificationContext(p *Sort_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sort_specification + p.RuleIndex = YQLParserRULE_sort_specification } func (*Sort_specificationContext) IsSort_specificationContext() {} @@ -27730,7 +27730,7 @@ func NewSort_specificationContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sort_specification + p.RuleIndex = YQLParserRULE_sort_specification return p } @@ -27754,11 +27754,11 @@ func (s *Sort_specificationContext) Expr() IExprContext { } func (s *Sort_specificationContext) ASC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASC, 0) + return s.GetToken(YQLParserASC, 0) } func (s *Sort_specificationContext) DESC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDESC, 0) + return s.GetToken(YQLParserDESC, 0) } func (s *Sort_specificationContext) GetRuleContext() antlr.RuleContext { @@ -27771,13 +27771,13 @@ func (s *Sort_specificationContext) ToStringTree(ruleNames []string, recog antlr func (s *Sort_specificationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSort_specification(s) } } func (s *Sort_specificationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSort_specification(s) } } @@ -27785,9 +27785,9 @@ func (s *Sort_specificationContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Sort_specification() (localctx ISort_specificationContext) { +func (p *YQLParser) Sort_specification() (localctx ISort_specificationContext) { localctx = NewSort_specificationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 228, YQLv1Antlr4ParserRULE_sort_specification) + p.EnterRule(localctx, 228, YQLParserRULE_sort_specification) var _la int p.EnterOuterAlt(localctx, 1) @@ -27803,12 +27803,12 @@ func (p *YQLv1Antlr4Parser) Sort_specification() (localctx ISort_specificationCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserASC || _la == YQLv1Antlr4ParserDESC { + if _la == YQLParserASC || _la == YQLParserDESC { { p.SetState(1977) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserASC || _la == YQLv1Antlr4ParserDESC) { + if !(_la == YQLParserASC || _la == YQLParserDESC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -27859,13 +27859,13 @@ type Sort_specification_listContext struct { func NewEmptySort_specification_listContext() *Sort_specification_listContext { var p = new(Sort_specification_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sort_specification_list + p.RuleIndex = YQLParserRULE_sort_specification_list return p } func InitEmptySort_specification_listContext(p *Sort_specification_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sort_specification_list + p.RuleIndex = YQLParserRULE_sort_specification_list } func (*Sort_specification_listContext) IsSort_specification_listContext() {} @@ -27876,7 +27876,7 @@ func NewSort_specification_listContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sort_specification_list + p.RuleIndex = YQLParserRULE_sort_specification_list return p } @@ -27925,11 +27925,11 @@ func (s *Sort_specification_listContext) Sort_specification(i int) ISort_specifi } func (s *Sort_specification_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Sort_specification_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Sort_specification_listContext) GetRuleContext() antlr.RuleContext { @@ -27942,13 +27942,13 @@ func (s *Sort_specification_listContext) ToStringTree(ruleNames []string, recog func (s *Sort_specification_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSort_specification_list(s) } } func (s *Sort_specification_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSort_specification_list(s) } } @@ -27956,9 +27956,9 @@ func (s *Sort_specification_listContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Sort_specification_list() (localctx ISort_specification_listContext) { +func (p *YQLParser) Sort_specification_list() (localctx ISort_specification_listContext) { localctx = NewSort_specification_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 230, YQLv1Antlr4ParserRULE_sort_specification_list) + p.EnterRule(localctx, 230, YQLParserRULE_sort_specification_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -27974,10 +27974,10 @@ func (p *YQLv1Antlr4Parser) Sort_specification_list() (localctx ISort_specificat _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(1981) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28038,13 +28038,13 @@ type Select_stmtContext struct { func NewEmptySelect_stmtContext() *Select_stmtContext { var p = new(Select_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_stmt + p.RuleIndex = YQLParserRULE_select_stmt return p } func InitEmptySelect_stmtContext(p *Select_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_stmt + p.RuleIndex = YQLParserRULE_select_stmt } func (*Select_stmtContext) IsSelect_stmtContext() {} @@ -28055,7 +28055,7 @@ func NewSelect_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_select_stmt + p.RuleIndex = YQLParserRULE_select_stmt return p } @@ -28154,13 +28154,13 @@ func (s *Select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Select_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSelect_stmt(s) } } func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSelect_stmt(s) } } @@ -28168,9 +28168,9 @@ func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Select_stmt() (localctx ISelect_stmtContext) { +func (p *YQLParser) Select_stmt() (localctx ISelect_stmtContext) { localctx = NewSelect_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 232, YQLv1Antlr4ParserRULE_select_stmt) + p.EnterRule(localctx, 232, YQLParserRULE_select_stmt) var _la int p.EnterOuterAlt(localctx, 1) @@ -28186,7 +28186,7 @@ func (p *YQLv1Antlr4Parser) Select_stmt() (localctx ISelect_stmtContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserEXCEPT || _la == YQLv1Antlr4ParserINTERSECT || _la == YQLv1Antlr4ParserUNION { + for _la == YQLParserEXCEPT || _la == YQLParserINTERSECT || _la == YQLParserUNION { { p.SetState(1989) p.Select_op() @@ -28247,13 +28247,13 @@ type Select_unparenthesized_stmtContext struct { func NewEmptySelect_unparenthesized_stmtContext() *Select_unparenthesized_stmtContext { var p = new(Select_unparenthesized_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_unparenthesized_stmt + p.RuleIndex = YQLParserRULE_select_unparenthesized_stmt return p } func InitEmptySelect_unparenthesized_stmtContext(p *Select_unparenthesized_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_unparenthesized_stmt + p.RuleIndex = YQLParserRULE_select_unparenthesized_stmt } func (*Select_unparenthesized_stmtContext) IsSelect_unparenthesized_stmtContext() {} @@ -28264,7 +28264,7 @@ func NewSelect_unparenthesized_stmtContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_select_unparenthesized_stmt + p.RuleIndex = YQLParserRULE_select_unparenthesized_stmt return p } @@ -28379,13 +28379,13 @@ func (s *Select_unparenthesized_stmtContext) ToStringTree(ruleNames []string, re func (s *Select_unparenthesized_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSelect_unparenthesized_stmt(s) } } func (s *Select_unparenthesized_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSelect_unparenthesized_stmt(s) } } @@ -28393,9 +28393,9 @@ func (s *Select_unparenthesized_stmtContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Select_unparenthesized_stmt() (localctx ISelect_unparenthesized_stmtContext) { +func (p *YQLParser) Select_unparenthesized_stmt() (localctx ISelect_unparenthesized_stmtContext) { localctx = NewSelect_unparenthesized_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 234, YQLv1Antlr4ParserRULE_select_unparenthesized_stmt) + p.EnterRule(localctx, 234, YQLParserRULE_select_unparenthesized_stmt) var _la int p.EnterOuterAlt(localctx, 1) @@ -28411,7 +28411,7 @@ func (p *YQLv1Antlr4Parser) Select_unparenthesized_stmt() (localctx ISelect_unpa _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserEXCEPT || _la == YQLv1Antlr4ParserINTERSECT || _la == YQLv1Antlr4ParserUNION { + for _la == YQLParserEXCEPT || _la == YQLParserINTERSECT || _la == YQLParserUNION { { p.SetState(1998) p.Select_op() @@ -28470,13 +28470,13 @@ type Select_kind_parenthesisContext struct { func NewEmptySelect_kind_parenthesisContext() *Select_kind_parenthesisContext { var p = new(Select_kind_parenthesisContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind_parenthesis + p.RuleIndex = YQLParserRULE_select_kind_parenthesis return p } func InitEmptySelect_kind_parenthesisContext(p *Select_kind_parenthesisContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind_parenthesis + p.RuleIndex = YQLParserRULE_select_kind_parenthesis } func (*Select_kind_parenthesisContext) IsSelect_kind_parenthesisContext() {} @@ -28487,7 +28487,7 @@ func NewSelect_kind_parenthesisContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind_parenthesis + p.RuleIndex = YQLParserRULE_select_kind_parenthesis return p } @@ -28511,11 +28511,11 @@ func (s *Select_kind_parenthesisContext) Select_kind_partial() ISelect_kind_part } func (s *Select_kind_parenthesisContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Select_kind_parenthesisContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Select_kind_parenthesisContext) GetRuleContext() antlr.RuleContext { @@ -28528,13 +28528,13 @@ func (s *Select_kind_parenthesisContext) ToStringTree(ruleNames []string, recog func (s *Select_kind_parenthesisContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSelect_kind_parenthesis(s) } } func (s *Select_kind_parenthesisContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSelect_kind_parenthesis(s) } } @@ -28542,9 +28542,9 @@ func (s *Select_kind_parenthesisContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Select_kind_parenthesis() (localctx ISelect_kind_parenthesisContext) { +func (p *YQLParser) Select_kind_parenthesis() (localctx ISelect_kind_parenthesisContext) { localctx = NewSelect_kind_parenthesisContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 236, YQLv1Antlr4ParserRULE_select_kind_parenthesis) + p.EnterRule(localctx, 236, YQLParserRULE_select_kind_parenthesis) p.SetState(2011) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -28552,7 +28552,7 @@ func (p *YQLv1Antlr4Parser) Select_kind_parenthesis() (localctx ISelect_kind_par } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserSELECT: + case YQLParserDISCARD, YQLParserFROM, YQLParserPROCESS, YQLParserREDUCE, YQLParserSELECT: p.EnterOuterAlt(localctx, 1) { p.SetState(2006) @@ -28560,11 +28560,11 @@ func (p *YQLv1Antlr4Parser) Select_kind_parenthesis() (localctx ISelect_kind_par } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(2007) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28576,7 +28576,7 @@ func (p *YQLv1Antlr4Parser) Select_kind_parenthesis() (localctx ISelect_kind_par } { p.SetState(2009) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28630,13 +28630,13 @@ type Select_opContext struct { func NewEmptySelect_opContext() *Select_opContext { var p = new(Select_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_op + p.RuleIndex = YQLParserRULE_select_op return p } func InitEmptySelect_opContext(p *Select_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_op + p.RuleIndex = YQLParserRULE_select_op } func (*Select_opContext) IsSelect_opContext() {} @@ -28647,7 +28647,7 @@ func NewSelect_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_select_op + p.RuleIndex = YQLParserRULE_select_op return p } @@ -28655,19 +28655,19 @@ func NewSelect_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *Select_opContext) GetParser() antlr.Parser { return s.parser } func (s *Select_opContext) UNION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNION, 0) + return s.GetToken(YQLParserUNION, 0) } func (s *Select_opContext) ALL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALL, 0) + return s.GetToken(YQLParserALL, 0) } func (s *Select_opContext) INTERSECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINTERSECT, 0) + return s.GetToken(YQLParserINTERSECT, 0) } func (s *Select_opContext) EXCEPT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCEPT, 0) + return s.GetToken(YQLParserEXCEPT, 0) } func (s *Select_opContext) GetRuleContext() antlr.RuleContext { @@ -28680,13 +28680,13 @@ func (s *Select_opContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Select_opContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSelect_op(s) } } func (s *Select_opContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSelect_op(s) } } @@ -28694,9 +28694,9 @@ func (s *Select_opContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Select_op() (localctx ISelect_opContext) { +func (p *YQLParser) Select_op() (localctx ISelect_opContext) { localctx = NewSelect_opContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 238, YQLv1Antlr4ParserRULE_select_op) + p.EnterRule(localctx, 238, YQLParserRULE_select_op) var _la int p.SetState(2019) @@ -28706,11 +28706,11 @@ func (p *YQLv1Antlr4Parser) Select_op() (localctx ISelect_opContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserUNION: + case YQLParserUNION: p.EnterOuterAlt(localctx, 1) { p.SetState(2013) - p.Match(YQLv1Antlr4ParserUNION) + p.Match(YQLParserUNION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28724,10 +28724,10 @@ func (p *YQLv1Antlr4Parser) Select_op() (localctx ISelect_opContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserALL { + if _la == YQLParserALL { { p.SetState(2014) - p.Match(YQLv1Antlr4ParserALL) + p.Match(YQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28737,11 +28737,11 @@ func (p *YQLv1Antlr4Parser) Select_op() (localctx ISelect_opContext) { } - case YQLv1Antlr4ParserINTERSECT: + case YQLParserINTERSECT: p.EnterOuterAlt(localctx, 2) { p.SetState(2017) - p.Match(YQLv1Antlr4ParserINTERSECT) + p.Match(YQLParserINTERSECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28749,11 +28749,11 @@ func (p *YQLv1Antlr4Parser) Select_op() (localctx ISelect_opContext) { } - case YQLv1Antlr4ParserEXCEPT: + case YQLParserEXCEPT: p.EnterOuterAlt(localctx, 3) { p.SetState(2018) - p.Match(YQLv1Antlr4ParserEXCEPT) + p.Match(YQLParserEXCEPT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28809,13 +28809,13 @@ type Select_kind_partialContext struct { func NewEmptySelect_kind_partialContext() *Select_kind_partialContext { var p = new(Select_kind_partialContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind_partial + p.RuleIndex = YQLParserRULE_select_kind_partial return p } func InitEmptySelect_kind_partialContext(p *Select_kind_partialContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind_partial + p.RuleIndex = YQLParserRULE_select_kind_partial } func (*Select_kind_partialContext) IsSelect_kind_partialContext() {} @@ -28826,7 +28826,7 @@ func NewSelect_kind_partialContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind_partial + p.RuleIndex = YQLParserRULE_select_kind_partial return p } @@ -28850,7 +28850,7 @@ func (s *Select_kind_partialContext) Select_kind() ISelect_kindContext { } func (s *Select_kind_partialContext) LIMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIMIT, 0) + return s.GetToken(YQLParserLIMIT, 0) } func (s *Select_kind_partialContext) AllExpr() []IExprContext { @@ -28895,11 +28895,11 @@ func (s *Select_kind_partialContext) Expr(i int) IExprContext { } func (s *Select_kind_partialContext) OFFSET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOFFSET, 0) + return s.GetToken(YQLParserOFFSET, 0) } func (s *Select_kind_partialContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Select_kind_partialContext) GetRuleContext() antlr.RuleContext { @@ -28912,13 +28912,13 @@ func (s *Select_kind_partialContext) ToStringTree(ruleNames []string, recog antl func (s *Select_kind_partialContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSelect_kind_partial(s) } } func (s *Select_kind_partialContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSelect_kind_partial(s) } } @@ -28926,9 +28926,9 @@ func (s *Select_kind_partialContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Select_kind_partial() (localctx ISelect_kind_partialContext) { +func (p *YQLParser) Select_kind_partial() (localctx ISelect_kind_partialContext) { localctx = NewSelect_kind_partialContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 240, YQLv1Antlr4ParserRULE_select_kind_partial) + p.EnterRule(localctx, 240, YQLParserRULE_select_kind_partial) var _la int p.EnterOuterAlt(localctx, 1) @@ -28944,10 +28944,10 @@ func (p *YQLv1Antlr4Parser) Select_kind_partial() (localctx ISelect_kind_partial _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLIMIT { + if _la == YQLParserLIMIT { { p.SetState(2022) - p.Match(YQLv1Antlr4ParserLIMIT) + p.Match(YQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28965,12 +28965,12 @@ func (p *YQLv1Antlr4Parser) Select_kind_partial() (localctx ISelect_kind_partial _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA || _la == YQLv1Antlr4ParserOFFSET { + if _la == YQLParserCOMMA || _la == YQLParserOFFSET { { p.SetState(2024) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserCOMMA || _la == YQLv1Antlr4ParserOFFSET) { + if !(_la == YQLParserCOMMA || _la == YQLParserOFFSET) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -29030,13 +29030,13 @@ type Select_kindContext struct { func NewEmptySelect_kindContext() *Select_kindContext { var p = new(Select_kindContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind + p.RuleIndex = YQLParserRULE_select_kind return p } func InitEmptySelect_kindContext(p *Select_kindContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind + p.RuleIndex = YQLParserRULE_select_kind } func (*Select_kindContext) IsSelect_kindContext() {} @@ -29047,7 +29047,7 @@ func NewSelect_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_select_kind + p.RuleIndex = YQLParserRULE_select_kind return p } @@ -29103,15 +29103,15 @@ func (s *Select_kindContext) Select_core() ISelect_coreContext { } func (s *Select_kindContext) DISCARD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISCARD, 0) + return s.GetToken(YQLParserDISCARD, 0) } func (s *Select_kindContext) INTO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINTO, 0) + return s.GetToken(YQLParserINTO, 0) } func (s *Select_kindContext) RESULT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESULT, 0) + return s.GetToken(YQLParserRESULT, 0) } func (s *Select_kindContext) Pure_column_or_named() IPure_column_or_namedContext { @@ -29140,13 +29140,13 @@ func (s *Select_kindContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Select_kindContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSelect_kind(s) } } func (s *Select_kindContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSelect_kind(s) } } @@ -29154,9 +29154,9 @@ func (s *Select_kindContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Select_kind() (localctx ISelect_kindContext) { +func (p *YQLParser) Select_kind() (localctx ISelect_kindContext) { localctx = NewSelect_kindContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 242, YQLv1Antlr4ParserRULE_select_kind) + p.EnterRule(localctx, 242, YQLParserRULE_select_kind) var _la int p.EnterOuterAlt(localctx, 1) @@ -29168,10 +29168,10 @@ func (p *YQLv1Antlr4Parser) Select_kind() (localctx ISelect_kindContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDISCARD { + if _la == YQLParserDISCARD { { p.SetState(2030) - p.Match(YQLv1Antlr4ParserDISCARD) + p.Match(YQLParserDISCARD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29186,21 +29186,21 @@ func (p *YQLv1Antlr4Parser) Select_kind() (localctx ISelect_kindContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserPROCESS: + case YQLParserPROCESS: { p.SetState(2033) p.Process_core() } - case YQLv1Antlr4ParserREDUCE: + case YQLParserREDUCE: { p.SetState(2034) p.Reduce_core() } - case YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserSELECT: + case YQLParserFROM, YQLParserSELECT: { p.SetState(2035) p.Select_core() @@ -29220,10 +29220,10 @@ func (p *YQLv1Antlr4Parser) Select_kind() (localctx ISelect_kindContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserINTO { + if _la == YQLParserINTO { { p.SetState(2038) - p.Match(YQLv1Antlr4ParserINTO) + p.Match(YQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29231,7 +29231,7 @@ func (p *YQLv1Antlr4Parser) Select_kind() (localctx ISelect_kindContext) { } { p.SetState(2039) - p.Match(YQLv1Antlr4ParserRESULT) + p.Match(YQLParserRESULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29299,13 +29299,13 @@ type Process_coreContext struct { func NewEmptyProcess_coreContext() *Process_coreContext { var p = new(Process_coreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_process_core + p.RuleIndex = YQLParserRULE_process_core return p } func InitEmptyProcess_coreContext(p *Process_coreContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_process_core + p.RuleIndex = YQLParserRULE_process_core } func (*Process_coreContext) IsProcess_coreContext() {} @@ -29316,7 +29316,7 @@ func NewProcess_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_process_core + p.RuleIndex = YQLParserRULE_process_core return p } @@ -29324,7 +29324,7 @@ func NewProcess_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Process_coreContext) GetParser() antlr.Parser { return s.parser } func (s *Process_coreContext) PROCESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPROCESS, 0) + return s.GetToken(YQLParserPROCESS, 0) } func (s *Process_coreContext) AllNamed_single_source() []INamed_single_sourceContext { @@ -29369,19 +29369,19 @@ func (s *Process_coreContext) Named_single_source(i int) INamed_single_sourceCon } func (s *Process_coreContext) STREAM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTREAM, 0) + return s.GetToken(YQLParserSTREAM, 0) } func (s *Process_coreContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Process_coreContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Process_coreContext) USING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSING, 0) + return s.GetToken(YQLParserUSING, 0) } func (s *Process_coreContext) Using_call_expr() IUsing_call_exprContext { @@ -29401,7 +29401,7 @@ func (s *Process_coreContext) Using_call_expr() IUsing_call_exprContext { } func (s *Process_coreContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Process_coreContext) An_id() IAn_idContext { @@ -29421,7 +29421,7 @@ func (s *Process_coreContext) An_id() IAn_idContext { } func (s *Process_coreContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Process_coreContext) External_call_settings() IExternal_call_settingsContext { @@ -29441,7 +29441,7 @@ func (s *Process_coreContext) External_call_settings() IExternal_call_settingsCo } func (s *Process_coreContext) WHERE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHERE, 0) + return s.GetToken(YQLParserWHERE, 0) } func (s *Process_coreContext) AllExpr() []IExprContext { @@ -29486,11 +29486,11 @@ func (s *Process_coreContext) Expr(i int) IExprContext { } func (s *Process_coreContext) HAVING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHAVING, 0) + return s.GetToken(YQLParserHAVING, 0) } func (s *Process_coreContext) ASSUME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASSUME, 0) + return s.GetToken(YQLParserASSUME, 0) } func (s *Process_coreContext) Order_by_clause() IOrder_by_clauseContext { @@ -29519,13 +29519,13 @@ func (s *Process_coreContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Process_coreContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterProcess_core(s) } } func (s *Process_coreContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitProcess_core(s) } } @@ -29533,15 +29533,15 @@ func (s *Process_coreContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { +func (p *YQLParser) Process_core() (localctx IProcess_coreContext) { localctx = NewProcess_coreContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 244, YQLv1Antlr4ParserRULE_process_core) + p.EnterRule(localctx, 244, YQLParserRULE_process_core) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2043) - p.Match(YQLv1Antlr4ParserPROCESS) + p.Match(YQLParserPROCESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29554,7 +29554,7 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 161, p.GetParserRuleContext()) == 1 { { p.SetState(2044) - p.Match(YQLv1Antlr4ParserSTREAM) + p.Match(YQLParserSTREAM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29576,10 +29576,10 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2048) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29606,10 +29606,10 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserUSING { + if _la == YQLParserUSING { { p.SetState(2055) - p.Match(YQLv1Antlr4ParserUSING) + p.Match(YQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29627,10 +29627,10 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAS { + if _la == YQLParserAS { { p.SetState(2057) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29650,10 +29650,10 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(2061) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29673,10 +29673,10 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWHERE { + if _la == YQLParserWHERE { { p.SetState(2065) - p.Match(YQLv1Antlr4ParserWHERE) + p.Match(YQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29696,10 +29696,10 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserHAVING { + if _la == YQLParserHAVING { { p.SetState(2069) - p.Match(YQLv1Antlr4ParserHAVING) + p.Match(YQLParserHAVING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29719,10 +29719,10 @@ func (p *YQLv1Antlr4Parser) Process_core() (localctx IProcess_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserASSUME { + if _la == YQLParserASSUME { { p.SetState(2073) - p.Match(YQLv1Antlr4ParserASSUME) + p.Match(YQLParserASSUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29777,13 +29777,13 @@ type External_call_paramContext struct { func NewEmptyExternal_call_paramContext() *External_call_paramContext { var p = new(External_call_paramContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_external_call_param + p.RuleIndex = YQLParserRULE_external_call_param return p } func InitEmptyExternal_call_paramContext(p *External_call_paramContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_external_call_param + p.RuleIndex = YQLParserRULE_external_call_param } func (*External_call_paramContext) IsExternal_call_paramContext() {} @@ -29794,7 +29794,7 @@ func NewExternal_call_paramContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_external_call_param + p.RuleIndex = YQLParserRULE_external_call_param return p } @@ -29818,7 +29818,7 @@ func (s *External_call_paramContext) An_id() IAn_idContext { } func (s *External_call_paramContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *External_call_paramContext) Expr() IExprContext { @@ -29847,13 +29847,13 @@ func (s *External_call_paramContext) ToStringTree(ruleNames []string, recog antl func (s *External_call_paramContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExternal_call_param(s) } } func (s *External_call_paramContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExternal_call_param(s) } } @@ -29861,9 +29861,9 @@ func (s *External_call_paramContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) External_call_param() (localctx IExternal_call_paramContext) { +func (p *YQLParser) External_call_param() (localctx IExternal_call_paramContext) { localctx = NewExternal_call_paramContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 246, YQLv1Antlr4ParserRULE_external_call_param) + p.EnterRule(localctx, 246, YQLParserRULE_external_call_param) p.EnterOuterAlt(localctx, 1) { p.SetState(2079) @@ -29871,7 +29871,7 @@ func (p *YQLv1Antlr4Parser) External_call_param() (localctx IExternal_call_param } { p.SetState(2080) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29923,13 +29923,13 @@ type External_call_settingsContext struct { func NewEmptyExternal_call_settingsContext() *External_call_settingsContext { var p = new(External_call_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_external_call_settings + p.RuleIndex = YQLParserRULE_external_call_settings return p } func InitEmptyExternal_call_settingsContext(p *External_call_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_external_call_settings + p.RuleIndex = YQLParserRULE_external_call_settings } func (*External_call_settingsContext) IsExternal_call_settingsContext() {} @@ -29940,7 +29940,7 @@ func NewExternal_call_settingsContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_external_call_settings + p.RuleIndex = YQLParserRULE_external_call_settings return p } @@ -29989,11 +29989,11 @@ func (s *External_call_settingsContext) External_call_param(i int) IExternal_cal } func (s *External_call_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *External_call_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *External_call_settingsContext) GetRuleContext() antlr.RuleContext { @@ -30006,13 +30006,13 @@ func (s *External_call_settingsContext) ToStringTree(ruleNames []string, recog a func (s *External_call_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExternal_call_settings(s) } } func (s *External_call_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExternal_call_settings(s) } } @@ -30020,9 +30020,9 @@ func (s *External_call_settingsContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) External_call_settings() (localctx IExternal_call_settingsContext) { +func (p *YQLParser) External_call_settings() (localctx IExternal_call_settingsContext) { localctx = NewExternal_call_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 248, YQLv1Antlr4ParserRULE_external_call_settings) + p.EnterRule(localctx, 248, YQLParserRULE_external_call_settings) var _la int p.EnterOuterAlt(localctx, 1) @@ -30038,10 +30038,10 @@ func (p *YQLv1Antlr4Parser) External_call_settings() (localctx IExternal_call_se _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2084) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30118,13 +30118,13 @@ type Reduce_coreContext struct { func NewEmptyReduce_coreContext() *Reduce_coreContext { var p = new(Reduce_coreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_reduce_core + p.RuleIndex = YQLParserRULE_reduce_core return p } func InitEmptyReduce_coreContext(p *Reduce_coreContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_reduce_core + p.RuleIndex = YQLParserRULE_reduce_core } func (*Reduce_coreContext) IsReduce_coreContext() {} @@ -30135,7 +30135,7 @@ func NewReduce_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_reduce_core + p.RuleIndex = YQLParserRULE_reduce_core return p } @@ -30143,7 +30143,7 @@ func NewReduce_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Reduce_coreContext) GetParser() antlr.Parser { return s.parser } func (s *Reduce_coreContext) REDUCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREDUCE, 0) + return s.GetToken(YQLParserREDUCE, 0) } func (s *Reduce_coreContext) AllNamed_single_source() []INamed_single_sourceContext { @@ -30188,7 +30188,7 @@ func (s *Reduce_coreContext) Named_single_source(i int) INamed_single_sourceCont } func (s *Reduce_coreContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Reduce_coreContext) Column_list() IColumn_listContext { @@ -30208,7 +30208,7 @@ func (s *Reduce_coreContext) Column_list() IColumn_listContext { } func (s *Reduce_coreContext) USING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSING, 0) + return s.GetToken(YQLParserUSING, 0) } func (s *Reduce_coreContext) Using_call_expr() IUsing_call_exprContext { @@ -30228,15 +30228,15 @@ func (s *Reduce_coreContext) Using_call_expr() IUsing_call_exprContext { } func (s *Reduce_coreContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Reduce_coreContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Reduce_coreContext) PRESORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRESORT, 0) + return s.GetToken(YQLParserPRESORT, 0) } func (s *Reduce_coreContext) Sort_specification_list() ISort_specification_listContext { @@ -30256,11 +30256,11 @@ func (s *Reduce_coreContext) Sort_specification_list() ISort_specification_listC } func (s *Reduce_coreContext) ALL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALL, 0) + return s.GetToken(YQLParserALL, 0) } func (s *Reduce_coreContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Reduce_coreContext) An_id() IAn_idContext { @@ -30280,7 +30280,7 @@ func (s *Reduce_coreContext) An_id() IAn_idContext { } func (s *Reduce_coreContext) WHERE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHERE, 0) + return s.GetToken(YQLParserWHERE, 0) } func (s *Reduce_coreContext) AllExpr() []IExprContext { @@ -30325,11 +30325,11 @@ func (s *Reduce_coreContext) Expr(i int) IExprContext { } func (s *Reduce_coreContext) HAVING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHAVING, 0) + return s.GetToken(YQLParserHAVING, 0) } func (s *Reduce_coreContext) ASSUME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASSUME, 0) + return s.GetToken(YQLParserASSUME, 0) } func (s *Reduce_coreContext) Order_by_clause() IOrder_by_clauseContext { @@ -30358,13 +30358,13 @@ func (s *Reduce_coreContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Reduce_coreContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterReduce_core(s) } } func (s *Reduce_coreContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitReduce_core(s) } } @@ -30372,15 +30372,15 @@ func (s *Reduce_coreContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { +func (p *YQLParser) Reduce_core() (localctx IReduce_coreContext) { localctx = NewReduce_coreContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 250, YQLv1Antlr4ParserRULE_reduce_core) + p.EnterRule(localctx, 250, YQLParserRULE_reduce_core) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2091) - p.Match(YQLv1Antlr4ParserREDUCE) + p.Match(YQLParserREDUCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30398,10 +30398,10 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2093) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30428,10 +30428,10 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPRESORT { + if _la == YQLParserPRESORT { { p.SetState(2100) - p.Match(YQLv1Antlr4ParserPRESORT) + p.Match(YQLParserPRESORT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30445,7 +30445,7 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { } { p.SetState(2104) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30457,7 +30457,7 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { } { p.SetState(2106) - p.Match(YQLv1Antlr4ParserUSING) + p.Match(YQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30470,7 +30470,7 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 172, p.GetParserRuleContext()) == 1 { { p.SetState(2107) - p.Match(YQLv1Antlr4ParserALL) + p.Match(YQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30492,10 +30492,10 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAS { + if _la == YQLParserAS { { p.SetState(2111) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30515,10 +30515,10 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWHERE { + if _la == YQLParserWHERE { { p.SetState(2115) - p.Match(YQLv1Antlr4ParserWHERE) + p.Match(YQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30538,10 +30538,10 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserHAVING { + if _la == YQLParserHAVING { { p.SetState(2119) - p.Match(YQLv1Antlr4ParserHAVING) + p.Match(YQLParserHAVING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30561,10 +30561,10 @@ func (p *YQLv1Antlr4Parser) Reduce_core() (localctx IReduce_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserASSUME { + if _la == YQLParserASSUME { { p.SetState(2123) - p.Match(YQLv1Antlr4ParserASSUME) + p.Match(YQLParserASSUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30616,13 +30616,13 @@ type Opt_set_quantifierContext struct { func NewEmptyOpt_set_quantifierContext() *Opt_set_quantifierContext { var p = new(Opt_set_quantifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_set_quantifier + p.RuleIndex = YQLParserRULE_opt_set_quantifier return p } func InitEmptyOpt_set_quantifierContext(p *Opt_set_quantifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_set_quantifier + p.RuleIndex = YQLParserRULE_opt_set_quantifier } func (*Opt_set_quantifierContext) IsOpt_set_quantifierContext() {} @@ -30633,7 +30633,7 @@ func NewOpt_set_quantifierContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_set_quantifier + p.RuleIndex = YQLParserRULE_opt_set_quantifier return p } @@ -30641,11 +30641,11 @@ func NewOpt_set_quantifierContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Opt_set_quantifierContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_set_quantifierContext) ALL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALL, 0) + return s.GetToken(YQLParserALL, 0) } func (s *Opt_set_quantifierContext) DISTINCT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISTINCT, 0) + return s.GetToken(YQLParserDISTINCT, 0) } func (s *Opt_set_quantifierContext) GetRuleContext() antlr.RuleContext { @@ -30658,13 +30658,13 @@ func (s *Opt_set_quantifierContext) ToStringTree(ruleNames []string, recog antlr func (s *Opt_set_quantifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOpt_set_quantifier(s) } } func (s *Opt_set_quantifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOpt_set_quantifier(s) } } @@ -30672,9 +30672,9 @@ func (s *Opt_set_quantifierContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Opt_set_quantifier() (localctx IOpt_set_quantifierContext) { +func (p *YQLParser) Opt_set_quantifier() (localctx IOpt_set_quantifierContext) { localctx = NewOpt_set_quantifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 252, YQLv1Antlr4ParserRULE_opt_set_quantifier) + p.EnterRule(localctx, 252, YQLParserRULE_opt_set_quantifier) var _la int p.EnterOuterAlt(localctx, 1) @@ -30687,7 +30687,7 @@ func (p *YQLv1Antlr4Parser) Opt_set_quantifier() (localctx IOpt_set_quantifierCo p.SetState(2127) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserALL || _la == YQLv1Antlr4ParserDISTINCT) { + if !(_la == YQLParserALL || _la == YQLParserDISTINCT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -30756,13 +30756,13 @@ type Select_coreContext struct { func NewEmptySelect_coreContext() *Select_coreContext { var p = new(Select_coreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_core + p.RuleIndex = YQLParserRULE_select_core return p } func InitEmptySelect_coreContext(p *Select_coreContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_select_core + p.RuleIndex = YQLParserRULE_select_core } func (*Select_coreContext) IsSelect_coreContext() {} @@ -30773,7 +30773,7 @@ func NewSelect_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_select_core + p.RuleIndex = YQLParserRULE_select_core return p } @@ -30781,7 +30781,7 @@ func NewSelect_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Select_coreContext) GetParser() antlr.Parser { return s.parser } func (s *Select_coreContext) SELECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSELECT, 0) + return s.GetToken(YQLParserSELECT, 0) } func (s *Select_coreContext) Opt_set_quantifier() IOpt_set_quantifierContext { @@ -30842,11 +30842,11 @@ func (s *Select_coreContext) Result_column(i int) IResult_columnContext { } func (s *Select_coreContext) AllFROM() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserFROM) + return s.GetTokens(YQLParserFROM) } func (s *Select_coreContext) FROM(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFROM, i) + return s.GetToken(YQLParserFROM, i) } func (s *Select_coreContext) AllJoin_source() []IJoin_sourceContext { @@ -30891,19 +30891,19 @@ func (s *Select_coreContext) Join_source(i int) IJoin_sourceContext { } func (s *Select_coreContext) STREAM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTREAM, 0) + return s.GetToken(YQLParserSTREAM, 0) } func (s *Select_coreContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Select_coreContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Select_coreContext) WITHOUT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITHOUT, 0) + return s.GetToken(YQLParserWITHOUT, 0) } func (s *Select_coreContext) Without_column_list() IWithout_column_listContext { @@ -30923,7 +30923,7 @@ func (s *Select_coreContext) Without_column_list() IWithout_column_listContext { } func (s *Select_coreContext) WHERE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHERE, 0) + return s.GetToken(YQLParserWHERE, 0) } func (s *Select_coreContext) AllExpr() []IExprContext { @@ -30984,7 +30984,7 @@ func (s *Select_coreContext) Group_by_clause() IGroup_by_clauseContext { } func (s *Select_coreContext) HAVING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHAVING, 0) + return s.GetToken(YQLParserHAVING, 0) } func (s *Select_coreContext) Window_clause() IWindow_clauseContext { @@ -31029,13 +31029,13 @@ func (s *Select_coreContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Select_coreContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSelect_core(s) } } func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSelect_core(s) } } @@ -31043,9 +31043,9 @@ func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { +func (p *YQLParser) Select_core() (localctx ISelect_coreContext) { localctx = NewSelect_coreContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 254, YQLv1Antlr4ParserRULE_select_core) + p.EnterRule(localctx, 254, YQLParserRULE_select_core) var _la int var _alt int @@ -31059,10 +31059,10 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserFROM { + if _la == YQLParserFROM { { p.SetState(2130) - p.Match(YQLv1Antlr4ParserFROM) + p.Match(YQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31076,7 +31076,7 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { } { p.SetState(2134) - p.Match(YQLv1Antlr4ParserSELECT) + p.Match(YQLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31089,7 +31089,7 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 179, p.GetParserRuleContext()) == 1 { { p.SetState(2135) - p.Match(YQLv1Antlr4ParserSTREAM) + p.Match(YQLParserSTREAM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31120,7 +31120,7 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { if _alt == 1 { { p.SetState(2140) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31151,10 +31151,10 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(2147) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31170,10 +31170,10 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITHOUT { + if _la == YQLParserWITHOUT { { p.SetState(2150) - p.Match(YQLv1Antlr4ParserWITHOUT) + p.Match(YQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31193,10 +31193,10 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserFROM { + if _la == YQLParserFROM { { p.SetState(2154) - p.Match(YQLv1Antlr4ParserFROM) + p.Match(YQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31216,10 +31216,10 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWHERE { + if _la == YQLParserWHERE { { p.SetState(2158) - p.Match(YQLv1Antlr4ParserWHERE) + p.Match(YQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31239,7 +31239,7 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserGROUP { + if _la == YQLParserGROUP { { p.SetState(2162) p.Group_by_clause() @@ -31254,10 +31254,10 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserHAVING { + if _la == YQLParserHAVING { { p.SetState(2165) - p.Match(YQLv1Antlr4ParserHAVING) + p.Match(YQLParserHAVING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31277,7 +31277,7 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWINDOW { + if _la == YQLParserWINDOW { { p.SetState(2169) p.Window_clause() @@ -31292,7 +31292,7 @@ func (p *YQLv1Antlr4Parser) Select_core() (localctx ISelect_coreContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserASSUME || _la == YQLv1Antlr4ParserORDER { + if _la == YQLParserASSUME || _la == YQLParserORDER { { p.SetState(2172) p.Ext_order_by_clause() @@ -31345,13 +31345,13 @@ type Row_pattern_recognition_clauseContext struct { func NewEmptyRow_pattern_recognition_clauseContext() *Row_pattern_recognition_clauseContext { var p = new(Row_pattern_recognition_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_recognition_clause + p.RuleIndex = YQLParserRULE_row_pattern_recognition_clause return p } func InitEmptyRow_pattern_recognition_clauseContext(p *Row_pattern_recognition_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_recognition_clause + p.RuleIndex = YQLParserRULE_row_pattern_recognition_clause } func (*Row_pattern_recognition_clauseContext) IsRow_pattern_recognition_clauseContext() {} @@ -31362,7 +31362,7 @@ func NewRow_pattern_recognition_clauseContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_recognition_clause + p.RuleIndex = YQLParserRULE_row_pattern_recognition_clause return p } @@ -31370,11 +31370,11 @@ func NewRow_pattern_recognition_clauseContext(parser antlr.Parser, parent antlr. func (s *Row_pattern_recognition_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_recognition_clauseContext) MATCH_RECOGNIZE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH_RECOGNIZE, 0) + return s.GetToken(YQLParserMATCH_RECOGNIZE, 0) } func (s *Row_pattern_recognition_clauseContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Row_pattern_recognition_clauseContext) Row_pattern_common_syntax() IRow_pattern_common_syntaxContext { @@ -31394,7 +31394,7 @@ func (s *Row_pattern_recognition_clauseContext) Row_pattern_common_syntax() IRow } func (s *Row_pattern_recognition_clauseContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Row_pattern_recognition_clauseContext) Window_partition_clause() IWindow_partition_clauseContext { @@ -31471,13 +31471,13 @@ func (s *Row_pattern_recognition_clauseContext) ToStringTree(ruleNames []string, func (s *Row_pattern_recognition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_recognition_clause(s) } } func (s *Row_pattern_recognition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_recognition_clause(s) } } @@ -31485,15 +31485,15 @@ func (s *Row_pattern_recognition_clauseContext) ExitRule(listener antlr.ParseTre -func (p *YQLv1Antlr4Parser) Row_pattern_recognition_clause() (localctx IRow_pattern_recognition_clauseContext) { +func (p *YQLParser) Row_pattern_recognition_clause() (localctx IRow_pattern_recognition_clauseContext) { localctx = NewRow_pattern_recognition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 256, YQLv1Antlr4ParserRULE_row_pattern_recognition_clause) + p.EnterRule(localctx, 256, YQLParserRULE_row_pattern_recognition_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2175) - p.Match(YQLv1Antlr4ParserMATCH_RECOGNIZE) + p.Match(YQLParserMATCH_RECOGNIZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31501,7 +31501,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_recognition_clause() (localctx IRow_patt } { p.SetState(2176) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31515,7 +31515,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_recognition_clause() (localctx IRow_patt _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPARTITION { + if _la == YQLParserPARTITION { { p.SetState(2177) p.Window_partition_clause() @@ -31530,7 +31530,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_recognition_clause() (localctx IRow_patt _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserORDER { + if _la == YQLParserORDER { { p.SetState(2180) p.Order_by_clause() @@ -31545,7 +31545,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_recognition_clause() (localctx IRow_patt _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserMEASURES { + if _la == YQLParserMEASURES { { p.SetState(2183) p.Row_pattern_measures() @@ -31560,7 +31560,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_recognition_clause() (localctx IRow_patt _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserALL || _la == YQLv1Antlr4ParserONE { + if _la == YQLParserALL || _la == YQLParserONE { { p.SetState(2186) p.Row_pattern_rows_per_match() @@ -31573,7 +31573,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_recognition_clause() (localctx IRow_patt } { p.SetState(2190) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31624,13 +31624,13 @@ type Row_pattern_rows_per_matchContext struct { func NewEmptyRow_pattern_rows_per_matchContext() *Row_pattern_rows_per_matchContext { var p = new(Row_pattern_rows_per_matchContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_rows_per_match + p.RuleIndex = YQLParserRULE_row_pattern_rows_per_match return p } func InitEmptyRow_pattern_rows_per_matchContext(p *Row_pattern_rows_per_matchContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_rows_per_match + p.RuleIndex = YQLParserRULE_row_pattern_rows_per_match } func (*Row_pattern_rows_per_matchContext) IsRow_pattern_rows_per_matchContext() {} @@ -31641,7 +31641,7 @@ func NewRow_pattern_rows_per_matchContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_rows_per_match + p.RuleIndex = YQLParserRULE_row_pattern_rows_per_match return p } @@ -31649,27 +31649,27 @@ func NewRow_pattern_rows_per_matchContext(parser antlr.Parser, parent antlr.Pars func (s *Row_pattern_rows_per_matchContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_rows_per_matchContext) ONE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserONE, 0) + return s.GetToken(YQLParserONE, 0) } func (s *Row_pattern_rows_per_matchContext) ROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROW, 0) + return s.GetToken(YQLParserROW, 0) } func (s *Row_pattern_rows_per_matchContext) PER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPER, 0) + return s.GetToken(YQLParserPER, 0) } func (s *Row_pattern_rows_per_matchContext) MATCH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH, 0) + return s.GetToken(YQLParserMATCH, 0) } func (s *Row_pattern_rows_per_matchContext) ALL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALL, 0) + return s.GetToken(YQLParserALL, 0) } func (s *Row_pattern_rows_per_matchContext) ROWS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROWS, 0) + return s.GetToken(YQLParserROWS, 0) } func (s *Row_pattern_rows_per_matchContext) Row_pattern_empty_match_handling() IRow_pattern_empty_match_handlingContext { @@ -31698,13 +31698,13 @@ func (s *Row_pattern_rows_per_matchContext) ToStringTree(ruleNames []string, rec func (s *Row_pattern_rows_per_matchContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_rows_per_match(s) } } func (s *Row_pattern_rows_per_matchContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_rows_per_match(s) } } @@ -31712,9 +31712,9 @@ func (s *Row_pattern_rows_per_matchContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_rows_per_matchContext) { +func (p *YQLParser) Row_pattern_rows_per_match() (localctx IRow_pattern_rows_per_matchContext) { localctx = NewRow_pattern_rows_per_matchContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 258, YQLv1Antlr4ParserRULE_row_pattern_rows_per_match) + p.EnterRule(localctx, 258, YQLParserRULE_row_pattern_rows_per_match) var _la int p.SetState(2203) @@ -31724,11 +31724,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserONE: + case YQLParserONE: p.EnterOuterAlt(localctx, 1) { p.SetState(2192) - p.Match(YQLv1Antlr4ParserONE) + p.Match(YQLParserONE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31736,7 +31736,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } { p.SetState(2193) - p.Match(YQLv1Antlr4ParserROW) + p.Match(YQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31744,7 +31744,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } { p.SetState(2194) - p.Match(YQLv1Antlr4ParserPER) + p.Match(YQLParserPER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31752,7 +31752,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } { p.SetState(2195) - p.Match(YQLv1Antlr4ParserMATCH) + p.Match(YQLParserMATCH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31760,11 +31760,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } - case YQLv1Antlr4ParserALL: + case YQLParserALL: p.EnterOuterAlt(localctx, 2) { p.SetState(2196) - p.Match(YQLv1Antlr4ParserALL) + p.Match(YQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31772,7 +31772,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } { p.SetState(2197) - p.Match(YQLv1Antlr4ParserROWS) + p.Match(YQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31780,7 +31780,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } { p.SetState(2198) - p.Match(YQLv1Antlr4ParserPER) + p.Match(YQLParserPER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31788,7 +31788,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ } { p.SetState(2199) - p.Match(YQLv1Antlr4ParserMATCH) + p.Match(YQLParserMATCH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31802,7 +31802,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_rows_per_match() (localctx IRow_pattern_ _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserOMIT || _la == YQLv1Antlr4ParserSHOW || _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserOMIT || _la == YQLParserSHOW || _la == YQLParserWITH { { p.SetState(2200) p.Row_pattern_empty_match_handling() @@ -31860,13 +31860,13 @@ type Row_pattern_empty_match_handlingContext struct { func NewEmptyRow_pattern_empty_match_handlingContext() *Row_pattern_empty_match_handlingContext { var p = new(Row_pattern_empty_match_handlingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_empty_match_handling + p.RuleIndex = YQLParserRULE_row_pattern_empty_match_handling return p } func InitEmptyRow_pattern_empty_match_handlingContext(p *Row_pattern_empty_match_handlingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_empty_match_handling + p.RuleIndex = YQLParserRULE_row_pattern_empty_match_handling } func (*Row_pattern_empty_match_handlingContext) IsRow_pattern_empty_match_handlingContext() {} @@ -31877,7 +31877,7 @@ func NewRow_pattern_empty_match_handlingContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_empty_match_handling + p.RuleIndex = YQLParserRULE_row_pattern_empty_match_handling return p } @@ -31885,31 +31885,31 @@ func NewRow_pattern_empty_match_handlingContext(parser antlr.Parser, parent antl func (s *Row_pattern_empty_match_handlingContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_empty_match_handlingContext) SHOW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSHOW, 0) + return s.GetToken(YQLParserSHOW, 0) } func (s *Row_pattern_empty_match_handlingContext) EMPTY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY, 0) + return s.GetToken(YQLParserEMPTY, 0) } func (s *Row_pattern_empty_match_handlingContext) MATCHES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCHES, 0) + return s.GetToken(YQLParserMATCHES, 0) } func (s *Row_pattern_empty_match_handlingContext) OMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOMIT, 0) + return s.GetToken(YQLParserOMIT, 0) } func (s *Row_pattern_empty_match_handlingContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Row_pattern_empty_match_handlingContext) UNMATCHED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNMATCHED, 0) + return s.GetToken(YQLParserUNMATCHED, 0) } func (s *Row_pattern_empty_match_handlingContext) ROWS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROWS, 0) + return s.GetToken(YQLParserROWS, 0) } func (s *Row_pattern_empty_match_handlingContext) GetRuleContext() antlr.RuleContext { @@ -31922,13 +31922,13 @@ func (s *Row_pattern_empty_match_handlingContext) ToStringTree(ruleNames []strin func (s *Row_pattern_empty_match_handlingContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_empty_match_handling(s) } } func (s *Row_pattern_empty_match_handlingContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_empty_match_handling(s) } } @@ -31936,9 +31936,9 @@ func (s *Row_pattern_empty_match_handlingContext) ExitRule(listener antlr.ParseT -func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pattern_empty_match_handlingContext) { +func (p *YQLParser) Row_pattern_empty_match_handling() (localctx IRow_pattern_empty_match_handlingContext) { localctx = NewRow_pattern_empty_match_handlingContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 260, YQLv1Antlr4ParserRULE_row_pattern_empty_match_handling) + p.EnterRule(localctx, 260, YQLParserRULE_row_pattern_empty_match_handling) p.SetState(2214) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -31946,11 +31946,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSHOW: + case YQLParserSHOW: p.EnterOuterAlt(localctx, 1) { p.SetState(2205) - p.Match(YQLv1Antlr4ParserSHOW) + p.Match(YQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31958,7 +31958,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } { p.SetState(2206) - p.Match(YQLv1Antlr4ParserEMPTY) + p.Match(YQLParserEMPTY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31966,7 +31966,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } { p.SetState(2207) - p.Match(YQLv1Antlr4ParserMATCHES) + p.Match(YQLParserMATCHES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31974,11 +31974,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } - case YQLv1Antlr4ParserOMIT: + case YQLParserOMIT: p.EnterOuterAlt(localctx, 2) { p.SetState(2208) - p.Match(YQLv1Antlr4ParserOMIT) + p.Match(YQLParserOMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31986,7 +31986,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } { p.SetState(2209) - p.Match(YQLv1Antlr4ParserEMPTY) + p.Match(YQLParserEMPTY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31994,7 +31994,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } { p.SetState(2210) - p.Match(YQLv1Antlr4ParserMATCHES) + p.Match(YQLParserMATCHES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32002,11 +32002,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } - case YQLv1Antlr4ParserWITH: + case YQLParserWITH: p.EnterOuterAlt(localctx, 3) { p.SetState(2211) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32014,7 +32014,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } { p.SetState(2212) - p.Match(YQLv1Antlr4ParserUNMATCHED) + p.Match(YQLParserUNMATCHED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32022,7 +32022,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_empty_match_handling() (localctx IRow_pa } { p.SetState(2213) - p.Match(YQLv1Antlr4ParserROWS) + p.Match(YQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32074,13 +32074,13 @@ type Row_pattern_measuresContext struct { func NewEmptyRow_pattern_measuresContext() *Row_pattern_measuresContext { var p = new(Row_pattern_measuresContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measures + p.RuleIndex = YQLParserRULE_row_pattern_measures return p } func InitEmptyRow_pattern_measuresContext(p *Row_pattern_measuresContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measures + p.RuleIndex = YQLParserRULE_row_pattern_measures } func (*Row_pattern_measuresContext) IsRow_pattern_measuresContext() {} @@ -32091,7 +32091,7 @@ func NewRow_pattern_measuresContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measures + p.RuleIndex = YQLParserRULE_row_pattern_measures return p } @@ -32099,7 +32099,7 @@ func NewRow_pattern_measuresContext(parser antlr.Parser, parent antlr.ParserRule func (s *Row_pattern_measuresContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_measuresContext) MEASURES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMEASURES, 0) + return s.GetToken(YQLParserMEASURES, 0) } func (s *Row_pattern_measuresContext) Row_pattern_measure_list() IRow_pattern_measure_listContext { @@ -32128,13 +32128,13 @@ func (s *Row_pattern_measuresContext) ToStringTree(ruleNames []string, recog ant func (s *Row_pattern_measuresContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_measures(s) } } func (s *Row_pattern_measuresContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_measures(s) } } @@ -32142,13 +32142,13 @@ func (s *Row_pattern_measuresContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Row_pattern_measures() (localctx IRow_pattern_measuresContext) { +func (p *YQLParser) Row_pattern_measures() (localctx IRow_pattern_measuresContext) { localctx = NewRow_pattern_measuresContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 262, YQLv1Antlr4ParserRULE_row_pattern_measures) + p.EnterRule(localctx, 262, YQLParserRULE_row_pattern_measures) p.EnterOuterAlt(localctx, 1) { p.SetState(2216) - p.Match(YQLv1Antlr4ParserMEASURES) + p.Match(YQLParserMEASURES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32200,13 +32200,13 @@ type Row_pattern_measure_listContext struct { func NewEmptyRow_pattern_measure_listContext() *Row_pattern_measure_listContext { var p = new(Row_pattern_measure_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measure_list + p.RuleIndex = YQLParserRULE_row_pattern_measure_list return p } func InitEmptyRow_pattern_measure_listContext(p *Row_pattern_measure_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measure_list + p.RuleIndex = YQLParserRULE_row_pattern_measure_list } func (*Row_pattern_measure_listContext) IsRow_pattern_measure_listContext() {} @@ -32217,7 +32217,7 @@ func NewRow_pattern_measure_listContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measure_list + p.RuleIndex = YQLParserRULE_row_pattern_measure_list return p } @@ -32266,11 +32266,11 @@ func (s *Row_pattern_measure_listContext) Row_pattern_measure_definition(i int) } func (s *Row_pattern_measure_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Row_pattern_measure_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Row_pattern_measure_listContext) GetRuleContext() antlr.RuleContext { @@ -32283,13 +32283,13 @@ func (s *Row_pattern_measure_listContext) ToStringTree(ruleNames []string, recog func (s *Row_pattern_measure_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_measure_list(s) } } func (s *Row_pattern_measure_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_measure_list(s) } } @@ -32297,9 +32297,9 @@ func (s *Row_pattern_measure_listContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Row_pattern_measure_list() (localctx IRow_pattern_measure_listContext) { +func (p *YQLParser) Row_pattern_measure_list() (localctx IRow_pattern_measure_listContext) { localctx = NewRow_pattern_measure_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 264, YQLv1Antlr4ParserRULE_row_pattern_measure_list) + p.EnterRule(localctx, 264, YQLParserRULE_row_pattern_measure_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -32315,10 +32315,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_measure_list() (localctx IRow_pattern_me _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2220) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32378,13 +32378,13 @@ type Row_pattern_measure_definitionContext struct { func NewEmptyRow_pattern_measure_definitionContext() *Row_pattern_measure_definitionContext { var p = new(Row_pattern_measure_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measure_definition + p.RuleIndex = YQLParserRULE_row_pattern_measure_definition return p } func InitEmptyRow_pattern_measure_definitionContext(p *Row_pattern_measure_definitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measure_definition + p.RuleIndex = YQLParserRULE_row_pattern_measure_definition } func (*Row_pattern_measure_definitionContext) IsRow_pattern_measure_definitionContext() {} @@ -32395,7 +32395,7 @@ func NewRow_pattern_measure_definitionContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_measure_definition + p.RuleIndex = YQLParserRULE_row_pattern_measure_definition return p } @@ -32419,7 +32419,7 @@ func (s *Row_pattern_measure_definitionContext) Expr() IExprContext { } func (s *Row_pattern_measure_definitionContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Row_pattern_measure_definitionContext) An_id() IAn_idContext { @@ -32448,13 +32448,13 @@ func (s *Row_pattern_measure_definitionContext) ToStringTree(ruleNames []string, func (s *Row_pattern_measure_definitionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_measure_definition(s) } } func (s *Row_pattern_measure_definitionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_measure_definition(s) } } @@ -32462,9 +32462,9 @@ func (s *Row_pattern_measure_definitionContext) ExitRule(listener antlr.ParseTre -func (p *YQLv1Antlr4Parser) Row_pattern_measure_definition() (localctx IRow_pattern_measure_definitionContext) { +func (p *YQLParser) Row_pattern_measure_definition() (localctx IRow_pattern_measure_definitionContext) { localctx = NewRow_pattern_measure_definitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 266, YQLv1Antlr4ParserRULE_row_pattern_measure_definition) + p.EnterRule(localctx, 266, YQLParserRULE_row_pattern_measure_definition) p.EnterOuterAlt(localctx, 1) { p.SetState(2227) @@ -32472,7 +32472,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_measure_definition() (localctx IRow_patt } { p.SetState(2228) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32531,13 +32531,13 @@ type Row_pattern_common_syntaxContext struct { func NewEmptyRow_pattern_common_syntaxContext() *Row_pattern_common_syntaxContext { var p = new(Row_pattern_common_syntaxContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_common_syntax + p.RuleIndex = YQLParserRULE_row_pattern_common_syntax return p } func InitEmptyRow_pattern_common_syntaxContext(p *Row_pattern_common_syntaxContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_common_syntax + p.RuleIndex = YQLParserRULE_row_pattern_common_syntax } func (*Row_pattern_common_syntaxContext) IsRow_pattern_common_syntaxContext() {} @@ -32548,7 +32548,7 @@ func NewRow_pattern_common_syntaxContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_common_syntax + p.RuleIndex = YQLParserRULE_row_pattern_common_syntax return p } @@ -32556,11 +32556,11 @@ func NewRow_pattern_common_syntaxContext(parser antlr.Parser, parent antlr.Parse func (s *Row_pattern_common_syntaxContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_common_syntaxContext) PATTERN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPATTERN, 0) + return s.GetToken(YQLParserPATTERN, 0) } func (s *Row_pattern_common_syntaxContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Row_pattern_common_syntaxContext) Row_pattern() IRow_patternContext { @@ -32580,11 +32580,11 @@ func (s *Row_pattern_common_syntaxContext) Row_pattern() IRow_patternContext { } func (s *Row_pattern_common_syntaxContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Row_pattern_common_syntaxContext) DEFINE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFINE, 0) + return s.GetToken(YQLParserDEFINE, 0) } func (s *Row_pattern_common_syntaxContext) Row_pattern_definition_list() IRow_pattern_definition_listContext { @@ -32604,11 +32604,11 @@ func (s *Row_pattern_common_syntaxContext) Row_pattern_definition_list() IRow_pa } func (s *Row_pattern_common_syntaxContext) AFTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAFTER, 0) + return s.GetToken(YQLParserAFTER, 0) } func (s *Row_pattern_common_syntaxContext) MATCH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH, 0) + return s.GetToken(YQLParserMATCH, 0) } func (s *Row_pattern_common_syntaxContext) Row_pattern_skip_to() IRow_pattern_skip_toContext { @@ -32669,13 +32669,13 @@ func (s *Row_pattern_common_syntaxContext) ToStringTree(ruleNames []string, reco func (s *Row_pattern_common_syntaxContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_common_syntax(s) } } func (s *Row_pattern_common_syntaxContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_common_syntax(s) } } @@ -32683,9 +32683,9 @@ func (s *Row_pattern_common_syntaxContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_common_syntaxContext) { +func (p *YQLParser) Row_pattern_common_syntax() (localctx IRow_pattern_common_syntaxContext) { localctx = NewRow_pattern_common_syntaxContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 268, YQLv1Antlr4ParserRULE_row_pattern_common_syntax) + p.EnterRule(localctx, 268, YQLParserRULE_row_pattern_common_syntax) var _la int p.EnterOuterAlt(localctx, 1) @@ -32697,10 +32697,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAFTER { + if _la == YQLParserAFTER { { p.SetState(2231) - p.Match(YQLv1Antlr4ParserAFTER) + p.Match(YQLParserAFTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32708,7 +32708,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c } { p.SetState(2232) - p.Match(YQLv1Antlr4ParserMATCH) + p.Match(YQLParserMATCH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32728,7 +32728,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserINITIAL || _la == YQLv1Antlr4ParserSEEK { + if _la == YQLParserINITIAL || _la == YQLParserSEEK { { p.SetState(2236) p.Row_pattern_initial_or_seek() @@ -32737,7 +32737,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c } { p.SetState(2239) - p.Match(YQLv1Antlr4ParserPATTERN) + p.Match(YQLParserPATTERN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32745,7 +32745,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c } { p.SetState(2240) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32757,7 +32757,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c } { p.SetState(2242) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32771,7 +32771,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserSUBSET { + if _la == YQLParserSUBSET { { p.SetState(2243) p.Row_pattern_subset_clause() @@ -32780,7 +32780,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_common_syntax() (localctx IRow_pattern_c } { p.SetState(2246) - p.Match(YQLv1Antlr4ParserDEFINE) + p.Match(YQLParserDEFINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32836,13 +32836,13 @@ type Row_pattern_skip_toContext struct { func NewEmptyRow_pattern_skip_toContext() *Row_pattern_skip_toContext { var p = new(Row_pattern_skip_toContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_skip_to + p.RuleIndex = YQLParserRULE_row_pattern_skip_to return p } func InitEmptyRow_pattern_skip_toContext(p *Row_pattern_skip_toContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_skip_to + p.RuleIndex = YQLParserRULE_row_pattern_skip_to } func (*Row_pattern_skip_toContext) IsRow_pattern_skip_toContext() {} @@ -32853,7 +32853,7 @@ func NewRow_pattern_skip_toContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_skip_to + p.RuleIndex = YQLParserRULE_row_pattern_skip_to return p } @@ -32861,31 +32861,31 @@ func NewRow_pattern_skip_toContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *Row_pattern_skip_toContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_skip_toContext) TSKIP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTSKIP, 0) + return s.GetToken(YQLParserTSKIP, 0) } func (s *Row_pattern_skip_toContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Row_pattern_skip_toContext) NEXT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNEXT, 0) + return s.GetToken(YQLParserNEXT, 0) } func (s *Row_pattern_skip_toContext) ROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROW, 0) + return s.GetToken(YQLParserROW, 0) } func (s *Row_pattern_skip_toContext) PAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPAST, 0) + return s.GetToken(YQLParserPAST, 0) } func (s *Row_pattern_skip_toContext) LAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLAST, 0) + return s.GetToken(YQLParserLAST, 0) } func (s *Row_pattern_skip_toContext) FIRST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFIRST, 0) + return s.GetToken(YQLParserFIRST, 0) } func (s *Row_pattern_skip_toContext) Row_pattern_skip_to_variable_name() IRow_pattern_skip_to_variable_nameContext { @@ -32914,13 +32914,13 @@ func (s *Row_pattern_skip_toContext) ToStringTree(ruleNames []string, recog antl func (s *Row_pattern_skip_toContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_skip_to(s) } } func (s *Row_pattern_skip_toContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_skip_to(s) } } @@ -32928,9 +32928,9 @@ func (s *Row_pattern_skip_toContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_toContext) { +func (p *YQLParser) Row_pattern_skip_to() (localctx IRow_pattern_skip_toContext) { localctx = NewRow_pattern_skip_toContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 270, YQLv1Antlr4ParserRULE_row_pattern_skip_to) + p.EnterRule(localctx, 270, YQLParserRULE_row_pattern_skip_to) p.SetState(2268) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -32942,7 +32942,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to p.EnterOuterAlt(localctx, 1) { p.SetState(2249) - p.Match(YQLv1Antlr4ParserTSKIP) + p.Match(YQLParserTSKIP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32950,7 +32950,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2250) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32958,7 +32958,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2251) - p.Match(YQLv1Antlr4ParserNEXT) + p.Match(YQLParserNEXT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32966,7 +32966,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2252) - p.Match(YQLv1Antlr4ParserROW) + p.Match(YQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32978,7 +32978,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to p.EnterOuterAlt(localctx, 2) { p.SetState(2253) - p.Match(YQLv1Antlr4ParserTSKIP) + p.Match(YQLParserTSKIP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32986,7 +32986,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2254) - p.Match(YQLv1Antlr4ParserPAST) + p.Match(YQLParserPAST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32994,7 +32994,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2255) - p.Match(YQLv1Antlr4ParserLAST) + p.Match(YQLParserLAST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33002,7 +33002,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2256) - p.Match(YQLv1Antlr4ParserROW) + p.Match(YQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33014,7 +33014,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to p.EnterOuterAlt(localctx, 3) { p.SetState(2257) - p.Match(YQLv1Antlr4ParserTSKIP) + p.Match(YQLParserTSKIP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33022,7 +33022,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2258) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33030,7 +33030,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2259) - p.Match(YQLv1Antlr4ParserFIRST) + p.Match(YQLParserFIRST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33046,7 +33046,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to p.EnterOuterAlt(localctx, 4) { p.SetState(2261) - p.Match(YQLv1Antlr4ParserTSKIP) + p.Match(YQLParserTSKIP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33054,7 +33054,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2262) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33062,7 +33062,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2263) - p.Match(YQLv1Antlr4ParserLAST) + p.Match(YQLParserLAST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33078,7 +33078,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to p.EnterOuterAlt(localctx, 5) { p.SetState(2265) - p.Match(YQLv1Antlr4ParserTSKIP) + p.Match(YQLParserTSKIP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33086,7 +33086,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_skip_to() (localctx IRow_pattern_skip_to } { p.SetState(2266) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33138,13 +33138,13 @@ type Row_pattern_skip_to_variable_nameContext struct { func NewEmptyRow_pattern_skip_to_variable_nameContext() *Row_pattern_skip_to_variable_nameContext { var p = new(Row_pattern_skip_to_variable_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_skip_to_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_skip_to_variable_name return p } func InitEmptyRow_pattern_skip_to_variable_nameContext(p *Row_pattern_skip_to_variable_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_skip_to_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_skip_to_variable_name } func (*Row_pattern_skip_to_variable_nameContext) IsRow_pattern_skip_to_variable_nameContext() {} @@ -33155,7 +33155,7 @@ func NewRow_pattern_skip_to_variable_nameContext(parser antlr.Parser, parent ant antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_skip_to_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_skip_to_variable_name return p } @@ -33188,13 +33188,13 @@ func (s *Row_pattern_skip_to_variable_nameContext) ToStringTree(ruleNames []stri func (s *Row_pattern_skip_to_variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_skip_to_variable_name(s) } } func (s *Row_pattern_skip_to_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_skip_to_variable_name(s) } } @@ -33202,9 +33202,9 @@ func (s *Row_pattern_skip_to_variable_nameContext) ExitRule(listener antlr.Parse -func (p *YQLv1Antlr4Parser) Row_pattern_skip_to_variable_name() (localctx IRow_pattern_skip_to_variable_nameContext) { +func (p *YQLParser) Row_pattern_skip_to_variable_name() (localctx IRow_pattern_skip_to_variable_nameContext) { localctx = NewRow_pattern_skip_to_variable_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 272, YQLv1Antlr4ParserRULE_row_pattern_skip_to_variable_name) + p.EnterRule(localctx, 272, YQLParserRULE_row_pattern_skip_to_variable_name) p.EnterOuterAlt(localctx, 1) { p.SetState(2270) @@ -33250,13 +33250,13 @@ type Row_pattern_initial_or_seekContext struct { func NewEmptyRow_pattern_initial_or_seekContext() *Row_pattern_initial_or_seekContext { var p = new(Row_pattern_initial_or_seekContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_initial_or_seek + p.RuleIndex = YQLParserRULE_row_pattern_initial_or_seek return p } func InitEmptyRow_pattern_initial_or_seekContext(p *Row_pattern_initial_or_seekContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_initial_or_seek + p.RuleIndex = YQLParserRULE_row_pattern_initial_or_seek } func (*Row_pattern_initial_or_seekContext) IsRow_pattern_initial_or_seekContext() {} @@ -33267,7 +33267,7 @@ func NewRow_pattern_initial_or_seekContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_initial_or_seek + p.RuleIndex = YQLParserRULE_row_pattern_initial_or_seek return p } @@ -33275,11 +33275,11 @@ func NewRow_pattern_initial_or_seekContext(parser antlr.Parser, parent antlr.Par func (s *Row_pattern_initial_or_seekContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_initial_or_seekContext) INITIAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINITIAL, 0) + return s.GetToken(YQLParserINITIAL, 0) } func (s *Row_pattern_initial_or_seekContext) SEEK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEEK, 0) + return s.GetToken(YQLParserSEEK, 0) } func (s *Row_pattern_initial_or_seekContext) GetRuleContext() antlr.RuleContext { @@ -33292,13 +33292,13 @@ func (s *Row_pattern_initial_or_seekContext) ToStringTree(ruleNames []string, re func (s *Row_pattern_initial_or_seekContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_initial_or_seek(s) } } func (s *Row_pattern_initial_or_seekContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_initial_or_seek(s) } } @@ -33306,9 +33306,9 @@ func (s *Row_pattern_initial_or_seekContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Row_pattern_initial_or_seek() (localctx IRow_pattern_initial_or_seekContext) { +func (p *YQLParser) Row_pattern_initial_or_seek() (localctx IRow_pattern_initial_or_seekContext) { localctx = NewRow_pattern_initial_or_seekContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 274, YQLv1Antlr4ParserRULE_row_pattern_initial_or_seek) + p.EnterRule(localctx, 274, YQLParserRULE_row_pattern_initial_or_seek) var _la int p.EnterOuterAlt(localctx, 1) @@ -33316,7 +33316,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_initial_or_seek() (localctx IRow_pattern p.SetState(2272) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserINITIAL || _la == YQLv1Antlr4ParserSEEK) { + if !(_la == YQLParserINITIAL || _la == YQLParserSEEK) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -33365,13 +33365,13 @@ type Row_patternContext struct { func NewEmptyRow_patternContext() *Row_patternContext { var p = new(Row_patternContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern + p.RuleIndex = YQLParserRULE_row_pattern return p } func InitEmptyRow_patternContext(p *Row_patternContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern + p.RuleIndex = YQLParserRULE_row_pattern } func (*Row_patternContext) IsRow_patternContext() {} @@ -33382,7 +33382,7 @@ func NewRow_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern + p.RuleIndex = YQLParserRULE_row_pattern return p } @@ -33431,11 +33431,11 @@ func (s *Row_patternContext) Row_pattern_term(i int) IRow_pattern_termContext { } func (s *Row_patternContext) AllPIPE() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserPIPE) + return s.GetTokens(YQLParserPIPE) } func (s *Row_patternContext) PIPE(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPIPE, i) + return s.GetToken(YQLParserPIPE, i) } func (s *Row_patternContext) GetRuleContext() antlr.RuleContext { @@ -33448,13 +33448,13 @@ func (s *Row_patternContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Row_patternContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern(s) } } func (s *Row_patternContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern(s) } } @@ -33462,9 +33462,9 @@ func (s *Row_patternContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Row_pattern() (localctx IRow_patternContext) { +func (p *YQLParser) Row_pattern() (localctx IRow_patternContext) { localctx = NewRow_patternContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 276, YQLv1Antlr4ParserRULE_row_pattern) + p.EnterRule(localctx, 276, YQLParserRULE_row_pattern) var _la int p.EnterOuterAlt(localctx, 1) @@ -33480,10 +33480,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern() (localctx IRow_patternContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserPIPE { + for _la == YQLParserPIPE { { p.SetState(2275) - p.Match(YQLv1Antlr4ParserPIPE) + p.Match(YQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33542,13 +33542,13 @@ type Row_pattern_termContext struct { func NewEmptyRow_pattern_termContext() *Row_pattern_termContext { var p = new(Row_pattern_termContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_term + p.RuleIndex = YQLParserRULE_row_pattern_term return p } func InitEmptyRow_pattern_termContext(p *Row_pattern_termContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_term + p.RuleIndex = YQLParserRULE_row_pattern_term } func (*Row_pattern_termContext) IsRow_pattern_termContext() {} @@ -33559,7 +33559,7 @@ func NewRow_pattern_termContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_term + p.RuleIndex = YQLParserRULE_row_pattern_term return p } @@ -33617,13 +33617,13 @@ func (s *Row_pattern_termContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Row_pattern_termContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_term(s) } } func (s *Row_pattern_termContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_term(s) } } @@ -33631,9 +33631,9 @@ func (s *Row_pattern_termContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Row_pattern_term() (localctx IRow_pattern_termContext) { +func (p *YQLParser) Row_pattern_term() (localctx IRow_pattern_termContext) { localctx = NewRow_pattern_termContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 278, YQLv1Antlr4ParserRULE_row_pattern_term) + p.EnterRule(localctx, 278, YQLParserRULE_row_pattern_term) var _la int p.EnterOuterAlt(localctx, 1) @@ -33645,7 +33645,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_term() (localctx IRow_pattern_termContex _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 11844714496) != 0) || _la == YQLv1Antlr4ParserPERMUTE || _la == YQLv1Antlr4ParserID_PLAIN || _la == YQLv1Antlr4ParserID_QUOTED { + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 11844714496) != 0) || _la == YQLParserPERMUTE || _la == YQLParserID_PLAIN || _la == YQLParserID_QUOTED { { p.SetState(2282) p.Row_pattern_factor() @@ -33699,13 +33699,13 @@ type Row_pattern_factorContext struct { func NewEmptyRow_pattern_factorContext() *Row_pattern_factorContext { var p = new(Row_pattern_factorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_factor + p.RuleIndex = YQLParserRULE_row_pattern_factor return p } func InitEmptyRow_pattern_factorContext(p *Row_pattern_factorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_factor + p.RuleIndex = YQLParserRULE_row_pattern_factor } func (*Row_pattern_factorContext) IsRow_pattern_factorContext() {} @@ -33716,7 +33716,7 @@ func NewRow_pattern_factorContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_factor + p.RuleIndex = YQLParserRULE_row_pattern_factor return p } @@ -33765,13 +33765,13 @@ func (s *Row_pattern_factorContext) ToStringTree(ruleNames []string, recog antlr func (s *Row_pattern_factorContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_factor(s) } } func (s *Row_pattern_factorContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_factor(s) } } @@ -33779,9 +33779,9 @@ func (s *Row_pattern_factorContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Row_pattern_factor() (localctx IRow_pattern_factorContext) { +func (p *YQLParser) Row_pattern_factor() (localctx IRow_pattern_factorContext) { localctx = NewRow_pattern_factorContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 280, YQLv1Antlr4ParserRULE_row_pattern_factor) + p.EnterRule(localctx, 280, YQLParserRULE_row_pattern_factor) p.EnterOuterAlt(localctx, 1) { p.SetState(2287) @@ -33847,13 +33847,13 @@ type Row_pattern_quantifierContext struct { func NewEmptyRow_pattern_quantifierContext() *Row_pattern_quantifierContext { var p = new(Row_pattern_quantifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_quantifier + p.RuleIndex = YQLParserRULE_row_pattern_quantifier return p } func InitEmptyRow_pattern_quantifierContext(p *Row_pattern_quantifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_quantifier + p.RuleIndex = YQLParserRULE_row_pattern_quantifier } func (*Row_pattern_quantifierContext) IsRow_pattern_quantifierContext() {} @@ -33864,7 +33864,7 @@ func NewRow_pattern_quantifierContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_quantifier + p.RuleIndex = YQLParserRULE_row_pattern_quantifier return p } @@ -33872,31 +33872,31 @@ func NewRow_pattern_quantifierContext(parser antlr.Parser, parent antlr.ParserRu func (s *Row_pattern_quantifierContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_quantifierContext) ASTERISK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASTERISK, 0) + return s.GetToken(YQLParserASTERISK, 0) } func (s *Row_pattern_quantifierContext) AllQUESTION() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserQUESTION) + return s.GetTokens(YQLParserQUESTION) } func (s *Row_pattern_quantifierContext) QUESTION(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUESTION, i) + return s.GetToken(YQLParserQUESTION, i) } func (s *Row_pattern_quantifierContext) PLUS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPLUS, 0) + return s.GetToken(YQLParserPLUS, 0) } func (s *Row_pattern_quantifierContext) LBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_CURLY, 0) + return s.GetToken(YQLParserLBRACE_CURLY, 0) } func (s *Row_pattern_quantifierContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Row_pattern_quantifierContext) RBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_CURLY, 0) + return s.GetToken(YQLParserRBRACE_CURLY, 0) } func (s *Row_pattern_quantifierContext) AllInteger() []IIntegerContext { @@ -33950,13 +33950,13 @@ func (s *Row_pattern_quantifierContext) ToStringTree(ruleNames []string, recog a func (s *Row_pattern_quantifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_quantifier(s) } } func (s *Row_pattern_quantifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_quantifier(s) } } @@ -33964,9 +33964,9 @@ func (s *Row_pattern_quantifierContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quantifierContext) { +func (p *YQLParser) Row_pattern_quantifier() (localctx IRow_pattern_quantifierContext) { localctx = NewRow_pattern_quantifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 282, YQLv1Antlr4ParserRULE_row_pattern_quantifier) + p.EnterRule(localctx, 282, YQLParserRULE_row_pattern_quantifier) var _la int p.SetState(2319) @@ -33980,7 +33980,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan p.EnterOuterAlt(localctx, 1) { p.SetState(2291) - p.Match(YQLv1Antlr4ParserASTERISK) + p.Match(YQLParserASTERISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33994,10 +33994,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserQUESTION { + if _la == YQLParserQUESTION { { p.SetState(2292) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34011,7 +34011,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan p.EnterOuterAlt(localctx, 2) { p.SetState(2295) - p.Match(YQLv1Antlr4ParserPLUS) + p.Match(YQLParserPLUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34025,10 +34025,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserQUESTION { + if _la == YQLParserQUESTION { { p.SetState(2296) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34042,7 +34042,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan p.EnterOuterAlt(localctx, 3) { p.SetState(2299) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34056,10 +34056,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserQUESTION { + if _la == YQLParserQUESTION { { p.SetState(2300) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34073,7 +34073,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan p.EnterOuterAlt(localctx, 4) { p.SetState(2303) - p.Match(YQLv1Antlr4ParserLBRACE_CURLY) + p.Match(YQLParserLBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34087,7 +34087,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDIGITS || _la == YQLv1Antlr4ParserINTEGER_VALUE { + if _la == YQLParserDIGITS || _la == YQLParserINTEGER_VALUE { { p.SetState(2304) p.Integer() @@ -34096,7 +34096,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan } { p.SetState(2307) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34110,7 +34110,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDIGITS || _la == YQLv1Antlr4ParserINTEGER_VALUE { + if _la == YQLParserDIGITS || _la == YQLParserINTEGER_VALUE { { p.SetState(2308) p.Integer() @@ -34119,7 +34119,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan } { p.SetState(2311) - p.Match(YQLv1Antlr4ParserRBRACE_CURLY) + p.Match(YQLParserRBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34133,10 +34133,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserQUESTION { + if _la == YQLParserQUESTION { { p.SetState(2312) - p.Match(YQLv1Antlr4ParserQUESTION) + p.Match(YQLParserQUESTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34150,7 +34150,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan p.EnterOuterAlt(localctx, 5) { p.SetState(2315) - p.Match(YQLv1Antlr4ParserLBRACE_CURLY) + p.Match(YQLParserLBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34162,7 +34162,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_quantifier() (localctx IRow_pattern_quan } { p.SetState(2317) - p.Match(YQLv1Antlr4ParserRBRACE_CURLY) + p.Match(YQLParserRBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34220,13 +34220,13 @@ type Row_pattern_primaryContext struct { func NewEmptyRow_pattern_primaryContext() *Row_pattern_primaryContext { var p = new(Row_pattern_primaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_primary + p.RuleIndex = YQLParserRULE_row_pattern_primary return p } func InitEmptyRow_pattern_primaryContext(p *Row_pattern_primaryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_primary + p.RuleIndex = YQLParserRULE_row_pattern_primary } func (*Row_pattern_primaryContext) IsRow_pattern_primaryContext() {} @@ -34237,7 +34237,7 @@ func NewRow_pattern_primaryContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_primary + p.RuleIndex = YQLParserRULE_row_pattern_primary return p } @@ -34261,19 +34261,19 @@ func (s *Row_pattern_primaryContext) Row_pattern_primary_variable_name() IRow_pa } func (s *Row_pattern_primaryContext) DOLLAR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOLLAR, 0) + return s.GetToken(YQLParserDOLLAR, 0) } func (s *Row_pattern_primaryContext) CARET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCARET, 0) + return s.GetToken(YQLParserCARET, 0) } func (s *Row_pattern_primaryContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Row_pattern_primaryContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Row_pattern_primaryContext) Row_pattern() IRow_patternContext { @@ -34293,19 +34293,19 @@ func (s *Row_pattern_primaryContext) Row_pattern() IRow_patternContext { } func (s *Row_pattern_primaryContext) LBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLBRACE_CURLY, 0) + return s.GetToken(YQLParserLBRACE_CURLY, 0) } func (s *Row_pattern_primaryContext) AllMINUS() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserMINUS) + return s.GetTokens(YQLParserMINUS) } func (s *Row_pattern_primaryContext) MINUS(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMINUS, i) + return s.GetToken(YQLParserMINUS, i) } func (s *Row_pattern_primaryContext) RBRACE_CURLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRBRACE_CURLY, 0) + return s.GetToken(YQLParserRBRACE_CURLY, 0) } func (s *Row_pattern_primaryContext) Row_pattern_permute() IRow_pattern_permuteContext { @@ -34334,13 +34334,13 @@ func (s *Row_pattern_primaryContext) ToStringTree(ruleNames []string, recog antl func (s *Row_pattern_primaryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_primary(s) } } func (s *Row_pattern_primaryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_primary(s) } } @@ -34348,9 +34348,9 @@ func (s *Row_pattern_primaryContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primaryContext) { +func (p *YQLParser) Row_pattern_primary() (localctx IRow_pattern_primaryContext) { localctx = NewRow_pattern_primaryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 284, YQLv1Antlr4ParserRULE_row_pattern_primary) + p.EnterRule(localctx, 284, YQLParserRULE_row_pattern_primary) var _la int p.SetState(2336) @@ -34360,7 +34360,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(2321) @@ -34368,11 +34368,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 2) { p.SetState(2322) - p.Match(YQLv1Antlr4ParserDOLLAR) + p.Match(YQLParserDOLLAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34380,11 +34380,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } - case YQLv1Antlr4ParserCARET: + case YQLParserCARET: p.EnterOuterAlt(localctx, 3) { p.SetState(2323) - p.Match(YQLv1Antlr4ParserCARET) + p.Match(YQLParserCARET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34392,11 +34392,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: p.EnterOuterAlt(localctx, 4) { p.SetState(2324) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34410,7 +34410,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 11844714496) != 0) || _la == YQLv1Antlr4ParserPERMUTE || _la == YQLv1Antlr4ParserID_PLAIN || _la == YQLv1Antlr4ParserID_QUOTED { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 11844714496) != 0) || _la == YQLParserPERMUTE || _la == YQLParserID_PLAIN || _la == YQLParserID_QUOTED { { p.SetState(2325) p.Row_pattern() @@ -34419,7 +34419,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } { p.SetState(2328) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34427,11 +34427,11 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } - case YQLv1Antlr4ParserLBRACE_CURLY: + case YQLParserLBRACE_CURLY: p.EnterOuterAlt(localctx, 5) { p.SetState(2329) - p.Match(YQLv1Antlr4ParserLBRACE_CURLY) + p.Match(YQLParserLBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34439,7 +34439,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } { p.SetState(2330) - p.Match(YQLv1Antlr4ParserMINUS) + p.Match(YQLParserMINUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34451,7 +34451,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } { p.SetState(2332) - p.Match(YQLv1Antlr4ParserMINUS) + p.Match(YQLParserMINUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34459,7 +34459,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } { p.SetState(2333) - p.Match(YQLv1Antlr4ParserRBRACE_CURLY) + p.Match(YQLParserRBRACE_CURLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34467,7 +34467,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_primary() (localctx IRow_pattern_primary } - case YQLv1Antlr4ParserPERMUTE: + case YQLParserPERMUTE: p.EnterOuterAlt(localctx, 6) { p.SetState(2335) @@ -34518,13 +34518,13 @@ type Row_pattern_primary_variable_nameContext struct { func NewEmptyRow_pattern_primary_variable_nameContext() *Row_pattern_primary_variable_nameContext { var p = new(Row_pattern_primary_variable_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_primary_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_primary_variable_name return p } func InitEmptyRow_pattern_primary_variable_nameContext(p *Row_pattern_primary_variable_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_primary_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_primary_variable_name } func (*Row_pattern_primary_variable_nameContext) IsRow_pattern_primary_variable_nameContext() {} @@ -34535,7 +34535,7 @@ func NewRow_pattern_primary_variable_nameContext(parser antlr.Parser, parent ant antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_primary_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_primary_variable_name return p } @@ -34568,13 +34568,13 @@ func (s *Row_pattern_primary_variable_nameContext) ToStringTree(ruleNames []stri func (s *Row_pattern_primary_variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_primary_variable_name(s) } } func (s *Row_pattern_primary_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_primary_variable_name(s) } } @@ -34582,9 +34582,9 @@ func (s *Row_pattern_primary_variable_nameContext) ExitRule(listener antlr.Parse -func (p *YQLv1Antlr4Parser) Row_pattern_primary_variable_name() (localctx IRow_pattern_primary_variable_nameContext) { +func (p *YQLParser) Row_pattern_primary_variable_name() (localctx IRow_pattern_primary_variable_nameContext) { localctx = NewRow_pattern_primary_variable_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 286, YQLv1Antlr4ParserRULE_row_pattern_primary_variable_name) + p.EnterRule(localctx, 286, YQLParserRULE_row_pattern_primary_variable_name) p.EnterOuterAlt(localctx, 1) { p.SetState(2338) @@ -34635,13 +34635,13 @@ type Row_pattern_permuteContext struct { func NewEmptyRow_pattern_permuteContext() *Row_pattern_permuteContext { var p = new(Row_pattern_permuteContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_permute + p.RuleIndex = YQLParserRULE_row_pattern_permute return p } func InitEmptyRow_pattern_permuteContext(p *Row_pattern_permuteContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_permute + p.RuleIndex = YQLParserRULE_row_pattern_permute } func (*Row_pattern_permuteContext) IsRow_pattern_permuteContext() {} @@ -34652,7 +34652,7 @@ func NewRow_pattern_permuteContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_permute + p.RuleIndex = YQLParserRULE_row_pattern_permute return p } @@ -34660,11 +34660,11 @@ func NewRow_pattern_permuteContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *Row_pattern_permuteContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_permuteContext) PERMUTE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPERMUTE, 0) + return s.GetToken(YQLParserPERMUTE, 0) } func (s *Row_pattern_permuteContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Row_pattern_permuteContext) AllRow_pattern() []IRow_patternContext { @@ -34709,15 +34709,15 @@ func (s *Row_pattern_permuteContext) Row_pattern(i int) IRow_patternContext { } func (s *Row_pattern_permuteContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Row_pattern_permuteContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Row_pattern_permuteContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Row_pattern_permuteContext) GetRuleContext() antlr.RuleContext { @@ -34730,13 +34730,13 @@ func (s *Row_pattern_permuteContext) ToStringTree(ruleNames []string, recog antl func (s *Row_pattern_permuteContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_permute(s) } } func (s *Row_pattern_permuteContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_permute(s) } } @@ -34744,15 +34744,15 @@ func (s *Row_pattern_permuteContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Row_pattern_permute() (localctx IRow_pattern_permuteContext) { +func (p *YQLParser) Row_pattern_permute() (localctx IRow_pattern_permuteContext) { localctx = NewRow_pattern_permuteContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 288, YQLv1Antlr4ParserRULE_row_pattern_permute) + p.EnterRule(localctx, 288, YQLParserRULE_row_pattern_permute) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2340) - p.Match(YQLv1Antlr4ParserPERMUTE) + p.Match(YQLParserPERMUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34760,7 +34760,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_permute() (localctx IRow_pattern_permute } { p.SetState(2341) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34778,10 +34778,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_permute() (localctx IRow_pattern_permute _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2343) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34802,7 +34802,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_permute() (localctx IRow_pattern_permute } { p.SetState(2350) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34848,13 +34848,13 @@ type Row_pattern_subset_clauseContext struct { func NewEmptyRow_pattern_subset_clauseContext() *Row_pattern_subset_clauseContext { var p = new(Row_pattern_subset_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_clause + p.RuleIndex = YQLParserRULE_row_pattern_subset_clause return p } func InitEmptyRow_pattern_subset_clauseContext(p *Row_pattern_subset_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_clause + p.RuleIndex = YQLParserRULE_row_pattern_subset_clause } func (*Row_pattern_subset_clauseContext) IsRow_pattern_subset_clauseContext() {} @@ -34865,7 +34865,7 @@ func NewRow_pattern_subset_clauseContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_clause + p.RuleIndex = YQLParserRULE_row_pattern_subset_clause return p } @@ -34873,7 +34873,7 @@ func NewRow_pattern_subset_clauseContext(parser antlr.Parser, parent antlr.Parse func (s *Row_pattern_subset_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Row_pattern_subset_clauseContext) SUBSET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSUBSET, 0) + return s.GetToken(YQLParserSUBSET, 0) } func (s *Row_pattern_subset_clauseContext) Row_pattern_subset_list() IRow_pattern_subset_listContext { @@ -34902,13 +34902,13 @@ func (s *Row_pattern_subset_clauseContext) ToStringTree(ruleNames []string, reco func (s *Row_pattern_subset_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_subset_clause(s) } } func (s *Row_pattern_subset_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_subset_clause(s) } } @@ -34916,13 +34916,13 @@ func (s *Row_pattern_subset_clauseContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Row_pattern_subset_clause() (localctx IRow_pattern_subset_clauseContext) { +func (p *YQLParser) Row_pattern_subset_clause() (localctx IRow_pattern_subset_clauseContext) { localctx = NewRow_pattern_subset_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 290, YQLv1Antlr4ParserRULE_row_pattern_subset_clause) + p.EnterRule(localctx, 290, YQLParserRULE_row_pattern_subset_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(2352) - p.Match(YQLv1Antlr4ParserSUBSET) + p.Match(YQLParserSUBSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34974,13 +34974,13 @@ type Row_pattern_subset_listContext struct { func NewEmptyRow_pattern_subset_listContext() *Row_pattern_subset_listContext { var p = new(Row_pattern_subset_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_list + p.RuleIndex = YQLParserRULE_row_pattern_subset_list return p } func InitEmptyRow_pattern_subset_listContext(p *Row_pattern_subset_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_list + p.RuleIndex = YQLParserRULE_row_pattern_subset_list } func (*Row_pattern_subset_listContext) IsRow_pattern_subset_listContext() {} @@ -34991,7 +34991,7 @@ func NewRow_pattern_subset_listContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_list + p.RuleIndex = YQLParserRULE_row_pattern_subset_list return p } @@ -35040,11 +35040,11 @@ func (s *Row_pattern_subset_listContext) Row_pattern_subset_item(i int) IRow_pat } func (s *Row_pattern_subset_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Row_pattern_subset_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Row_pattern_subset_listContext) GetRuleContext() antlr.RuleContext { @@ -35057,13 +35057,13 @@ func (s *Row_pattern_subset_listContext) ToStringTree(ruleNames []string, recog func (s *Row_pattern_subset_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_subset_list(s) } } func (s *Row_pattern_subset_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_subset_list(s) } } @@ -35071,9 +35071,9 @@ func (s *Row_pattern_subset_listContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Row_pattern_subset_list() (localctx IRow_pattern_subset_listContext) { +func (p *YQLParser) Row_pattern_subset_list() (localctx IRow_pattern_subset_listContext) { localctx = NewRow_pattern_subset_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 292, YQLv1Antlr4ParserRULE_row_pattern_subset_list) + p.EnterRule(localctx, 292, YQLParserRULE_row_pattern_subset_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -35089,10 +35089,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_subset_list() (localctx IRow_pattern_sub _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2356) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35154,13 +35154,13 @@ type Row_pattern_subset_itemContext struct { func NewEmptyRow_pattern_subset_itemContext() *Row_pattern_subset_itemContext { var p = new(Row_pattern_subset_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_item + p.RuleIndex = YQLParserRULE_row_pattern_subset_item return p } func InitEmptyRow_pattern_subset_itemContext(p *Row_pattern_subset_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_item + p.RuleIndex = YQLParserRULE_row_pattern_subset_item } func (*Row_pattern_subset_itemContext) IsRow_pattern_subset_itemContext() {} @@ -35171,7 +35171,7 @@ func NewRow_pattern_subset_itemContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_item + p.RuleIndex = YQLParserRULE_row_pattern_subset_item return p } @@ -35195,11 +35195,11 @@ func (s *Row_pattern_subset_itemContext) Row_pattern_subset_item_variable_name() } func (s *Row_pattern_subset_itemContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Row_pattern_subset_itemContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Row_pattern_subset_itemContext) Row_pattern_subset_rhs() IRow_pattern_subset_rhsContext { @@ -35219,7 +35219,7 @@ func (s *Row_pattern_subset_itemContext) Row_pattern_subset_rhs() IRow_pattern_s } func (s *Row_pattern_subset_itemContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Row_pattern_subset_itemContext) GetRuleContext() antlr.RuleContext { @@ -35232,13 +35232,13 @@ func (s *Row_pattern_subset_itemContext) ToStringTree(ruleNames []string, recog func (s *Row_pattern_subset_itemContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_subset_item(s) } } func (s *Row_pattern_subset_itemContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_subset_item(s) } } @@ -35246,9 +35246,9 @@ func (s *Row_pattern_subset_itemContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Row_pattern_subset_item() (localctx IRow_pattern_subset_itemContext) { +func (p *YQLParser) Row_pattern_subset_item() (localctx IRow_pattern_subset_itemContext) { localctx = NewRow_pattern_subset_itemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 294, YQLv1Antlr4ParserRULE_row_pattern_subset_item) + p.EnterRule(localctx, 294, YQLParserRULE_row_pattern_subset_item) p.EnterOuterAlt(localctx, 1) { p.SetState(2363) @@ -35256,7 +35256,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_subset_item() (localctx IRow_pattern_sub } { p.SetState(2364) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35264,7 +35264,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_subset_item() (localctx IRow_pattern_sub } { p.SetState(2365) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35276,7 +35276,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_subset_item() (localctx IRow_pattern_sub } { p.SetState(2367) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35321,13 +35321,13 @@ type Row_pattern_subset_item_variable_nameContext struct { func NewEmptyRow_pattern_subset_item_variable_nameContext() *Row_pattern_subset_item_variable_nameContext { var p = new(Row_pattern_subset_item_variable_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_item_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_subset_item_variable_name return p } func InitEmptyRow_pattern_subset_item_variable_nameContext(p *Row_pattern_subset_item_variable_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_item_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_subset_item_variable_name } func (*Row_pattern_subset_item_variable_nameContext) IsRow_pattern_subset_item_variable_nameContext() {} @@ -35338,7 +35338,7 @@ func NewRow_pattern_subset_item_variable_nameContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_item_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_subset_item_variable_name return p } @@ -35371,13 +35371,13 @@ func (s *Row_pattern_subset_item_variable_nameContext) ToStringTree(ruleNames [] func (s *Row_pattern_subset_item_variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_subset_item_variable_name(s) } } func (s *Row_pattern_subset_item_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_subset_item_variable_name(s) } } @@ -35385,9 +35385,9 @@ func (s *Row_pattern_subset_item_variable_nameContext) ExitRule(listener antlr.P -func (p *YQLv1Antlr4Parser) Row_pattern_subset_item_variable_name() (localctx IRow_pattern_subset_item_variable_nameContext) { +func (p *YQLParser) Row_pattern_subset_item_variable_name() (localctx IRow_pattern_subset_item_variable_nameContext) { localctx = NewRow_pattern_subset_item_variable_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 296, YQLv1Antlr4ParserRULE_row_pattern_subset_item_variable_name) + p.EnterRule(localctx, 296, YQLParserRULE_row_pattern_subset_item_variable_name) p.EnterOuterAlt(localctx, 1) { p.SetState(2369) @@ -35435,13 +35435,13 @@ type Row_pattern_subset_rhsContext struct { func NewEmptyRow_pattern_subset_rhsContext() *Row_pattern_subset_rhsContext { var p = new(Row_pattern_subset_rhsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_rhs + p.RuleIndex = YQLParserRULE_row_pattern_subset_rhs return p } func InitEmptyRow_pattern_subset_rhsContext(p *Row_pattern_subset_rhsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_rhs + p.RuleIndex = YQLParserRULE_row_pattern_subset_rhs } func (*Row_pattern_subset_rhsContext) IsRow_pattern_subset_rhsContext() {} @@ -35452,7 +35452,7 @@ func NewRow_pattern_subset_rhsContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_rhs + p.RuleIndex = YQLParserRULE_row_pattern_subset_rhs return p } @@ -35501,11 +35501,11 @@ func (s *Row_pattern_subset_rhsContext) Row_pattern_subset_rhs_variable_name(i i } func (s *Row_pattern_subset_rhsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Row_pattern_subset_rhsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Row_pattern_subset_rhsContext) GetRuleContext() antlr.RuleContext { @@ -35518,13 +35518,13 @@ func (s *Row_pattern_subset_rhsContext) ToStringTree(ruleNames []string, recog a func (s *Row_pattern_subset_rhsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_subset_rhs(s) } } func (s *Row_pattern_subset_rhsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_subset_rhs(s) } } @@ -35532,9 +35532,9 @@ func (s *Row_pattern_subset_rhsContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Row_pattern_subset_rhs() (localctx IRow_pattern_subset_rhsContext) { +func (p *YQLParser) Row_pattern_subset_rhs() (localctx IRow_pattern_subset_rhsContext) { localctx = NewRow_pattern_subset_rhsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 298, YQLv1Antlr4ParserRULE_row_pattern_subset_rhs) + p.EnterRule(localctx, 298, YQLParserRULE_row_pattern_subset_rhs) var _la int p.EnterOuterAlt(localctx, 1) @@ -35550,10 +35550,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_subset_rhs() (localctx IRow_pattern_subs _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2372) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35611,13 +35611,13 @@ type Row_pattern_subset_rhs_variable_nameContext struct { func NewEmptyRow_pattern_subset_rhs_variable_nameContext() *Row_pattern_subset_rhs_variable_nameContext { var p = new(Row_pattern_subset_rhs_variable_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_rhs_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_subset_rhs_variable_name return p } func InitEmptyRow_pattern_subset_rhs_variable_nameContext(p *Row_pattern_subset_rhs_variable_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_rhs_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_subset_rhs_variable_name } func (*Row_pattern_subset_rhs_variable_nameContext) IsRow_pattern_subset_rhs_variable_nameContext() {} @@ -35628,7 +35628,7 @@ func NewRow_pattern_subset_rhs_variable_nameContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_subset_rhs_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_subset_rhs_variable_name return p } @@ -35661,13 +35661,13 @@ func (s *Row_pattern_subset_rhs_variable_nameContext) ToStringTree(ruleNames []s func (s *Row_pattern_subset_rhs_variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_subset_rhs_variable_name(s) } } func (s *Row_pattern_subset_rhs_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_subset_rhs_variable_name(s) } } @@ -35675,9 +35675,9 @@ func (s *Row_pattern_subset_rhs_variable_nameContext) ExitRule(listener antlr.Pa -func (p *YQLv1Antlr4Parser) Row_pattern_subset_rhs_variable_name() (localctx IRow_pattern_subset_rhs_variable_nameContext) { +func (p *YQLParser) Row_pattern_subset_rhs_variable_name() (localctx IRow_pattern_subset_rhs_variable_nameContext) { localctx = NewRow_pattern_subset_rhs_variable_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 300, YQLv1Antlr4ParserRULE_row_pattern_subset_rhs_variable_name) + p.EnterRule(localctx, 300, YQLParserRULE_row_pattern_subset_rhs_variable_name) p.EnterOuterAlt(localctx, 1) { p.SetState(2379) @@ -35725,13 +35725,13 @@ type Row_pattern_definition_listContext struct { func NewEmptyRow_pattern_definition_listContext() *Row_pattern_definition_listContext { var p = new(Row_pattern_definition_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_list + p.RuleIndex = YQLParserRULE_row_pattern_definition_list return p } func InitEmptyRow_pattern_definition_listContext(p *Row_pattern_definition_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_list + p.RuleIndex = YQLParserRULE_row_pattern_definition_list } func (*Row_pattern_definition_listContext) IsRow_pattern_definition_listContext() {} @@ -35742,7 +35742,7 @@ func NewRow_pattern_definition_listContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_list + p.RuleIndex = YQLParserRULE_row_pattern_definition_list return p } @@ -35791,11 +35791,11 @@ func (s *Row_pattern_definition_listContext) Row_pattern_definition(i int) IRow_ } func (s *Row_pattern_definition_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Row_pattern_definition_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Row_pattern_definition_listContext) GetRuleContext() antlr.RuleContext { @@ -35808,13 +35808,13 @@ func (s *Row_pattern_definition_listContext) ToStringTree(ruleNames []string, re func (s *Row_pattern_definition_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_definition_list(s) } } func (s *Row_pattern_definition_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_definition_list(s) } } @@ -35822,9 +35822,9 @@ func (s *Row_pattern_definition_listContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Row_pattern_definition_list() (localctx IRow_pattern_definition_listContext) { +func (p *YQLParser) Row_pattern_definition_list() (localctx IRow_pattern_definition_listContext) { localctx = NewRow_pattern_definition_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 302, YQLv1Antlr4ParserRULE_row_pattern_definition_list) + p.EnterRule(localctx, 302, YQLParserRULE_row_pattern_definition_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -35840,10 +35840,10 @@ func (p *YQLv1Antlr4Parser) Row_pattern_definition_list() (localctx IRow_pattern _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2382) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35903,13 +35903,13 @@ type Row_pattern_definitionContext struct { func NewEmptyRow_pattern_definitionContext() *Row_pattern_definitionContext { var p = new(Row_pattern_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition + p.RuleIndex = YQLParserRULE_row_pattern_definition return p } func InitEmptyRow_pattern_definitionContext(p *Row_pattern_definitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition + p.RuleIndex = YQLParserRULE_row_pattern_definition } func (*Row_pattern_definitionContext) IsRow_pattern_definitionContext() {} @@ -35920,7 +35920,7 @@ func NewRow_pattern_definitionContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition + p.RuleIndex = YQLParserRULE_row_pattern_definition return p } @@ -35944,7 +35944,7 @@ func (s *Row_pattern_definitionContext) Row_pattern_definition_variable_name() I } func (s *Row_pattern_definitionContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Row_pattern_definitionContext) Row_pattern_definition_search_condition() IRow_pattern_definition_search_conditionContext { @@ -35973,13 +35973,13 @@ func (s *Row_pattern_definitionContext) ToStringTree(ruleNames []string, recog a func (s *Row_pattern_definitionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_definition(s) } } func (s *Row_pattern_definitionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_definition(s) } } @@ -35987,9 +35987,9 @@ func (s *Row_pattern_definitionContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Row_pattern_definition() (localctx IRow_pattern_definitionContext) { +func (p *YQLParser) Row_pattern_definition() (localctx IRow_pattern_definitionContext) { localctx = NewRow_pattern_definitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 304, YQLv1Antlr4ParserRULE_row_pattern_definition) + p.EnterRule(localctx, 304, YQLParserRULE_row_pattern_definition) p.EnterOuterAlt(localctx, 1) { p.SetState(2389) @@ -35997,7 +35997,7 @@ func (p *YQLv1Antlr4Parser) Row_pattern_definition() (localctx IRow_pattern_defi } { p.SetState(2390) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36046,13 +36046,13 @@ type Row_pattern_definition_variable_nameContext struct { func NewEmptyRow_pattern_definition_variable_nameContext() *Row_pattern_definition_variable_nameContext { var p = new(Row_pattern_definition_variable_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_definition_variable_name return p } func InitEmptyRow_pattern_definition_variable_nameContext(p *Row_pattern_definition_variable_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_definition_variable_name } func (*Row_pattern_definition_variable_nameContext) IsRow_pattern_definition_variable_nameContext() {} @@ -36063,7 +36063,7 @@ func NewRow_pattern_definition_variable_nameContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_definition_variable_name return p } @@ -36096,13 +36096,13 @@ func (s *Row_pattern_definition_variable_nameContext) ToStringTree(ruleNames []s func (s *Row_pattern_definition_variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_definition_variable_name(s) } } func (s *Row_pattern_definition_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_definition_variable_name(s) } } @@ -36110,9 +36110,9 @@ func (s *Row_pattern_definition_variable_nameContext) ExitRule(listener antlr.Pa -func (p *YQLv1Antlr4Parser) Row_pattern_definition_variable_name() (localctx IRow_pattern_definition_variable_nameContext) { +func (p *YQLParser) Row_pattern_definition_variable_name() (localctx IRow_pattern_definition_variable_nameContext) { localctx = NewRow_pattern_definition_variable_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 306, YQLv1Antlr4ParserRULE_row_pattern_definition_variable_name) + p.EnterRule(localctx, 306, YQLParserRULE_row_pattern_definition_variable_name) p.EnterOuterAlt(localctx, 1) { p.SetState(2393) @@ -36157,13 +36157,13 @@ type Row_pattern_definition_search_conditionContext struct { func NewEmptyRow_pattern_definition_search_conditionContext() *Row_pattern_definition_search_conditionContext { var p = new(Row_pattern_definition_search_conditionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_search_condition + p.RuleIndex = YQLParserRULE_row_pattern_definition_search_condition return p } func InitEmptyRow_pattern_definition_search_conditionContext(p *Row_pattern_definition_search_conditionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_search_condition + p.RuleIndex = YQLParserRULE_row_pattern_definition_search_condition } func (*Row_pattern_definition_search_conditionContext) IsRow_pattern_definition_search_conditionContext() {} @@ -36174,7 +36174,7 @@ func NewRow_pattern_definition_search_conditionContext(parser antlr.Parser, pare antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_definition_search_condition + p.RuleIndex = YQLParserRULE_row_pattern_definition_search_condition return p } @@ -36207,13 +36207,13 @@ func (s *Row_pattern_definition_search_conditionContext) ToStringTree(ruleNames func (s *Row_pattern_definition_search_conditionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_definition_search_condition(s) } } func (s *Row_pattern_definition_search_conditionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_definition_search_condition(s) } } @@ -36221,9 +36221,9 @@ func (s *Row_pattern_definition_search_conditionContext) ExitRule(listener antlr -func (p *YQLv1Antlr4Parser) Row_pattern_definition_search_condition() (localctx IRow_pattern_definition_search_conditionContext) { +func (p *YQLParser) Row_pattern_definition_search_condition() (localctx IRow_pattern_definition_search_conditionContext) { localctx = NewRow_pattern_definition_search_conditionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 308, YQLv1Antlr4ParserRULE_row_pattern_definition_search_condition) + p.EnterRule(localctx, 308, YQLParserRULE_row_pattern_definition_search_condition) p.EnterOuterAlt(localctx, 1) { p.SetState(2395) @@ -36268,13 +36268,13 @@ type Search_conditionContext struct { func NewEmptySearch_conditionContext() *Search_conditionContext { var p = new(Search_conditionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_search_condition + p.RuleIndex = YQLParserRULE_search_condition return p } func InitEmptySearch_conditionContext(p *Search_conditionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_search_condition + p.RuleIndex = YQLParserRULE_search_condition } func (*Search_conditionContext) IsSearch_conditionContext() {} @@ -36285,7 +36285,7 @@ func NewSearch_conditionContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_search_condition + p.RuleIndex = YQLParserRULE_search_condition return p } @@ -36318,13 +36318,13 @@ func (s *Search_conditionContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Search_conditionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSearch_condition(s) } } func (s *Search_conditionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSearch_condition(s) } } @@ -36332,9 +36332,9 @@ func (s *Search_conditionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Search_condition() (localctx ISearch_conditionContext) { +func (p *YQLParser) Search_condition() (localctx ISearch_conditionContext) { localctx = NewSearch_conditionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 310, YQLv1Antlr4ParserRULE_search_condition) + p.EnterRule(localctx, 310, YQLParserRULE_search_condition) p.EnterOuterAlt(localctx, 1) { p.SetState(2397) @@ -36379,13 +36379,13 @@ type Row_pattern_variable_nameContext struct { func NewEmptyRow_pattern_variable_nameContext() *Row_pattern_variable_nameContext { var p = new(Row_pattern_variable_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_variable_name return p } func InitEmptyRow_pattern_variable_nameContext(p *Row_pattern_variable_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_variable_name } func (*Row_pattern_variable_nameContext) IsRow_pattern_variable_nameContext() {} @@ -36396,7 +36396,7 @@ func NewRow_pattern_variable_nameContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_row_pattern_variable_name + p.RuleIndex = YQLParserRULE_row_pattern_variable_name return p } @@ -36429,13 +36429,13 @@ func (s *Row_pattern_variable_nameContext) ToStringTree(ruleNames []string, reco func (s *Row_pattern_variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRow_pattern_variable_name(s) } } func (s *Row_pattern_variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRow_pattern_variable_name(s) } } @@ -36443,9 +36443,9 @@ func (s *Row_pattern_variable_nameContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Row_pattern_variable_name() (localctx IRow_pattern_variable_nameContext) { +func (p *YQLParser) Row_pattern_variable_name() (localctx IRow_pattern_variable_nameContext) { localctx = NewRow_pattern_variable_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 312, YQLv1Antlr4ParserRULE_row_pattern_variable_name) + p.EnterRule(localctx, 312, YQLParserRULE_row_pattern_variable_name) p.EnterOuterAlt(localctx, 1) { p.SetState(2399) @@ -36492,13 +36492,13 @@ type Order_by_clauseContext struct { func NewEmptyOrder_by_clauseContext() *Order_by_clauseContext { var p = new(Order_by_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_order_by_clause + p.RuleIndex = YQLParserRULE_order_by_clause return p } func InitEmptyOrder_by_clauseContext(p *Order_by_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_order_by_clause + p.RuleIndex = YQLParserRULE_order_by_clause } func (*Order_by_clauseContext) IsOrder_by_clauseContext() {} @@ -36509,7 +36509,7 @@ func NewOrder_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_order_by_clause + p.RuleIndex = YQLParserRULE_order_by_clause return p } @@ -36517,11 +36517,11 @@ func NewOrder_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Order_by_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Order_by_clauseContext) ORDER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserORDER, 0) + return s.GetToken(YQLParserORDER, 0) } func (s *Order_by_clauseContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Order_by_clauseContext) Sort_specification_list() ISort_specification_listContext { @@ -36550,13 +36550,13 @@ func (s *Order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOrder_by_clause(s) } } func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOrder_by_clause(s) } } @@ -36564,13 +36564,13 @@ func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Order_by_clause() (localctx IOrder_by_clauseContext) { +func (p *YQLParser) Order_by_clause() (localctx IOrder_by_clauseContext) { localctx = NewOrder_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 314, YQLv1Antlr4ParserRULE_order_by_clause) + p.EnterRule(localctx, 314, YQLParserRULE_order_by_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(2401) - p.Match(YQLv1Antlr4ParserORDER) + p.Match(YQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36578,7 +36578,7 @@ func (p *YQLv1Antlr4Parser) Order_by_clause() (localctx IOrder_by_clauseContext) } { p.SetState(2402) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36628,13 +36628,13 @@ type Ext_order_by_clauseContext struct { func NewEmptyExt_order_by_clauseContext() *Ext_order_by_clauseContext { var p = new(Ext_order_by_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ext_order_by_clause + p.RuleIndex = YQLParserRULE_ext_order_by_clause return p } func InitEmptyExt_order_by_clauseContext(p *Ext_order_by_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ext_order_by_clause + p.RuleIndex = YQLParserRULE_ext_order_by_clause } func (*Ext_order_by_clauseContext) IsExt_order_by_clauseContext() {} @@ -36645,7 +36645,7 @@ func NewExt_order_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_ext_order_by_clause + p.RuleIndex = YQLParserRULE_ext_order_by_clause return p } @@ -36669,7 +36669,7 @@ func (s *Ext_order_by_clauseContext) Order_by_clause() IOrder_by_clauseContext { } func (s *Ext_order_by_clauseContext) ASSUME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASSUME, 0) + return s.GetToken(YQLParserASSUME, 0) } func (s *Ext_order_by_clauseContext) GetRuleContext() antlr.RuleContext { @@ -36682,13 +36682,13 @@ func (s *Ext_order_by_clauseContext) ToStringTree(ruleNames []string, recog antl func (s *Ext_order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExt_order_by_clause(s) } } func (s *Ext_order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExt_order_by_clause(s) } } @@ -36696,9 +36696,9 @@ func (s *Ext_order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Ext_order_by_clause() (localctx IExt_order_by_clauseContext) { +func (p *YQLParser) Ext_order_by_clause() (localctx IExt_order_by_clauseContext) { localctx = NewExt_order_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 316, YQLv1Antlr4ParserRULE_ext_order_by_clause) + p.EnterRule(localctx, 316, YQLParserRULE_ext_order_by_clause) var _la int p.EnterOuterAlt(localctx, 1) @@ -36710,10 +36710,10 @@ func (p *YQLv1Antlr4Parser) Ext_order_by_clause() (localctx IExt_order_by_clause _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserASSUME { + if _la == YQLParserASSUME { { p.SetState(2405) - p.Match(YQLv1Antlr4ParserASSUME) + p.Match(YQLParserASSUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36770,13 +36770,13 @@ type Group_by_clauseContext struct { func NewEmptyGroup_by_clauseContext() *Group_by_clauseContext { var p = new(Group_by_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_group_by_clause + p.RuleIndex = YQLParserRULE_group_by_clause return p } func InitEmptyGroup_by_clauseContext(p *Group_by_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_group_by_clause + p.RuleIndex = YQLParserRULE_group_by_clause } func (*Group_by_clauseContext) IsGroup_by_clauseContext() {} @@ -36787,7 +36787,7 @@ func NewGroup_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_group_by_clause + p.RuleIndex = YQLParserRULE_group_by_clause return p } @@ -36795,11 +36795,11 @@ func NewGroup_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Group_by_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Group_by_clauseContext) GROUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUP, 0) + return s.GetToken(YQLParserGROUP, 0) } func (s *Group_by_clauseContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Group_by_clauseContext) Opt_set_quantifier() IOpt_set_quantifierContext { @@ -36835,11 +36835,11 @@ func (s *Group_by_clauseContext) Grouping_element_list() IGrouping_element_listC } func (s *Group_by_clauseContext) COMPACT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMPACT, 0) + return s.GetToken(YQLParserCOMPACT, 0) } func (s *Group_by_clauseContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Group_by_clauseContext) An_id() IAn_idContext { @@ -36868,13 +36868,13 @@ func (s *Group_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Group_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterGroup_by_clause(s) } } func (s *Group_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitGroup_by_clause(s) } } @@ -36882,15 +36882,15 @@ func (s *Group_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Group_by_clause() (localctx IGroup_by_clauseContext) { +func (p *YQLParser) Group_by_clause() (localctx IGroup_by_clauseContext) { localctx = NewGroup_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 318, YQLv1Antlr4ParserRULE_group_by_clause) + p.EnterRule(localctx, 318, YQLParserRULE_group_by_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2410) - p.Match(YQLv1Antlr4ParserGROUP) + p.Match(YQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36904,10 +36904,10 @@ func (p *YQLv1Antlr4Parser) Group_by_clause() (localctx IGroup_by_clauseContext) _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMPACT { + if _la == YQLParserCOMPACT { { p.SetState(2411) - p.Match(YQLv1Antlr4ParserCOMPACT) + p.Match(YQLParserCOMPACT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36917,7 +36917,7 @@ func (p *YQLv1Antlr4Parser) Group_by_clause() (localctx IGroup_by_clauseContext) } { p.SetState(2414) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36939,10 +36939,10 @@ func (p *YQLv1Antlr4Parser) Group_by_clause() (localctx IGroup_by_clauseContext) _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(2417) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36996,13 +36996,13 @@ type Grouping_element_listContext struct { func NewEmptyGrouping_element_listContext() *Grouping_element_listContext { var p = new(Grouping_element_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_element_list + p.RuleIndex = YQLParserRULE_grouping_element_list return p } func InitEmptyGrouping_element_listContext(p *Grouping_element_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_element_list + p.RuleIndex = YQLParserRULE_grouping_element_list } func (*Grouping_element_listContext) IsGrouping_element_listContext() {} @@ -37013,7 +37013,7 @@ func NewGrouping_element_listContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_element_list + p.RuleIndex = YQLParserRULE_grouping_element_list return p } @@ -37062,11 +37062,11 @@ func (s *Grouping_element_listContext) Grouping_element(i int) IGrouping_element } func (s *Grouping_element_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Grouping_element_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Grouping_element_listContext) GetRuleContext() antlr.RuleContext { @@ -37079,13 +37079,13 @@ func (s *Grouping_element_listContext) ToStringTree(ruleNames []string, recog an func (s *Grouping_element_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterGrouping_element_list(s) } } func (s *Grouping_element_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitGrouping_element_list(s) } } @@ -37093,9 +37093,9 @@ func (s *Grouping_element_listContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Grouping_element_list() (localctx IGrouping_element_listContext) { +func (p *YQLParser) Grouping_element_list() (localctx IGrouping_element_listContext) { localctx = NewGrouping_element_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 320, YQLv1Antlr4ParserRULE_grouping_element_list) + p.EnterRule(localctx, 320, YQLParserRULE_grouping_element_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -37111,10 +37111,10 @@ func (p *YQLv1Antlr4Parser) Grouping_element_list() (localctx IGrouping_element_ _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2422) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37176,13 +37176,13 @@ type Grouping_elementContext struct { func NewEmptyGrouping_elementContext() *Grouping_elementContext { var p = new(Grouping_elementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_element + p.RuleIndex = YQLParserRULE_grouping_element return p } func InitEmptyGrouping_elementContext(p *Grouping_elementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_element + p.RuleIndex = YQLParserRULE_grouping_element } func (*Grouping_elementContext) IsGrouping_elementContext() {} @@ -37193,7 +37193,7 @@ func NewGrouping_elementContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_element + p.RuleIndex = YQLParserRULE_grouping_element return p } @@ -37290,13 +37290,13 @@ func (s *Grouping_elementContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Grouping_elementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterGrouping_element(s) } } func (s *Grouping_elementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitGrouping_element(s) } } @@ -37304,9 +37304,9 @@ func (s *Grouping_elementContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Grouping_element() (localctx IGrouping_elementContext) { +func (p *YQLParser) Grouping_element() (localctx IGrouping_elementContext) { localctx = NewGrouping_elementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 322, YQLv1Antlr4ParserRULE_grouping_element) + p.EnterRule(localctx, 322, YQLParserRULE_grouping_element) p.SetState(2434) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -37394,13 +37394,13 @@ type Ordinary_grouping_setContext struct { func NewEmptyOrdinary_grouping_setContext() *Ordinary_grouping_setContext { var p = new(Ordinary_grouping_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ordinary_grouping_set + p.RuleIndex = YQLParserRULE_ordinary_grouping_set return p } func InitEmptyOrdinary_grouping_setContext(p *Ordinary_grouping_setContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ordinary_grouping_set + p.RuleIndex = YQLParserRULE_ordinary_grouping_set } func (*Ordinary_grouping_setContext) IsOrdinary_grouping_setContext() {} @@ -37411,7 +37411,7 @@ func NewOrdinary_grouping_setContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_ordinary_grouping_set + p.RuleIndex = YQLParserRULE_ordinary_grouping_set return p } @@ -37444,13 +37444,13 @@ func (s *Ordinary_grouping_setContext) ToStringTree(ruleNames []string, recog an func (s *Ordinary_grouping_setContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOrdinary_grouping_set(s) } } func (s *Ordinary_grouping_setContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOrdinary_grouping_set(s) } } @@ -37458,9 +37458,9 @@ func (s *Ordinary_grouping_setContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Ordinary_grouping_set() (localctx IOrdinary_grouping_setContext) { +func (p *YQLParser) Ordinary_grouping_set() (localctx IOrdinary_grouping_setContext) { localctx = NewOrdinary_grouping_setContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 324, YQLv1Antlr4ParserRULE_ordinary_grouping_set) + p.EnterRule(localctx, 324, YQLParserRULE_ordinary_grouping_set) p.EnterOuterAlt(localctx, 1) { p.SetState(2436) @@ -37508,13 +37508,13 @@ type Ordinary_grouping_set_listContext struct { func NewEmptyOrdinary_grouping_set_listContext() *Ordinary_grouping_set_listContext { var p = new(Ordinary_grouping_set_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ordinary_grouping_set_list + p.RuleIndex = YQLParserRULE_ordinary_grouping_set_list return p } func InitEmptyOrdinary_grouping_set_listContext(p *Ordinary_grouping_set_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ordinary_grouping_set_list + p.RuleIndex = YQLParserRULE_ordinary_grouping_set_list } func (*Ordinary_grouping_set_listContext) IsOrdinary_grouping_set_listContext() {} @@ -37525,7 +37525,7 @@ func NewOrdinary_grouping_set_listContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_ordinary_grouping_set_list + p.RuleIndex = YQLParserRULE_ordinary_grouping_set_list return p } @@ -37574,11 +37574,11 @@ func (s *Ordinary_grouping_set_listContext) Ordinary_grouping_set(i int) IOrdina } func (s *Ordinary_grouping_set_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Ordinary_grouping_set_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Ordinary_grouping_set_listContext) GetRuleContext() antlr.RuleContext { @@ -37591,13 +37591,13 @@ func (s *Ordinary_grouping_set_listContext) ToStringTree(ruleNames []string, rec func (s *Ordinary_grouping_set_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOrdinary_grouping_set_list(s) } } func (s *Ordinary_grouping_set_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOrdinary_grouping_set_list(s) } } @@ -37605,9 +37605,9 @@ func (s *Ordinary_grouping_set_listContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Ordinary_grouping_set_list() (localctx IOrdinary_grouping_set_listContext) { +func (p *YQLParser) Ordinary_grouping_set_list() (localctx IOrdinary_grouping_set_listContext) { localctx = NewOrdinary_grouping_set_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 326, YQLv1Antlr4ParserRULE_ordinary_grouping_set_list) + p.EnterRule(localctx, 326, YQLParserRULE_ordinary_grouping_set_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -37623,10 +37623,10 @@ func (p *YQLv1Antlr4Parser) Ordinary_grouping_set_list() (localctx IOrdinary_gro _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2439) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37687,13 +37687,13 @@ type Rollup_listContext struct { func NewEmptyRollup_listContext() *Rollup_listContext { var p = new(Rollup_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_rollup_list + p.RuleIndex = YQLParserRULE_rollup_list return p } func InitEmptyRollup_listContext(p *Rollup_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_rollup_list + p.RuleIndex = YQLParserRULE_rollup_list } func (*Rollup_listContext) IsRollup_listContext() {} @@ -37704,7 +37704,7 @@ func NewRollup_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_rollup_list + p.RuleIndex = YQLParserRULE_rollup_list return p } @@ -37712,11 +37712,11 @@ func NewRollup_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Rollup_listContext) GetParser() antlr.Parser { return s.parser } func (s *Rollup_listContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROLLUP, 0) + return s.GetToken(YQLParserROLLUP, 0) } func (s *Rollup_listContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Rollup_listContext) Ordinary_grouping_set_list() IOrdinary_grouping_set_listContext { @@ -37736,7 +37736,7 @@ func (s *Rollup_listContext) Ordinary_grouping_set_list() IOrdinary_grouping_set } func (s *Rollup_listContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Rollup_listContext) GetRuleContext() antlr.RuleContext { @@ -37749,13 +37749,13 @@ func (s *Rollup_listContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Rollup_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRollup_list(s) } } func (s *Rollup_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRollup_list(s) } } @@ -37763,13 +37763,13 @@ func (s *Rollup_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Rollup_list() (localctx IRollup_listContext) { +func (p *YQLParser) Rollup_list() (localctx IRollup_listContext) { localctx = NewRollup_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 328, YQLv1Antlr4ParserRULE_rollup_list) + p.EnterRule(localctx, 328, YQLParserRULE_rollup_list) p.EnterOuterAlt(localctx, 1) { p.SetState(2446) - p.Match(YQLv1Antlr4ParserROLLUP) + p.Match(YQLParserROLLUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37777,7 +37777,7 @@ func (p *YQLv1Antlr4Parser) Rollup_list() (localctx IRollup_listContext) { } { p.SetState(2447) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37789,7 +37789,7 @@ func (p *YQLv1Antlr4Parser) Rollup_list() (localctx IRollup_listContext) { } { p.SetState(2449) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37837,13 +37837,13 @@ type Cube_listContext struct { func NewEmptyCube_listContext() *Cube_listContext { var p = new(Cube_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cube_list + p.RuleIndex = YQLParserRULE_cube_list return p } func InitEmptyCube_listContext(p *Cube_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cube_list + p.RuleIndex = YQLParserRULE_cube_list } func (*Cube_listContext) IsCube_listContext() {} @@ -37854,7 +37854,7 @@ func NewCube_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_cube_list + p.RuleIndex = YQLParserRULE_cube_list return p } @@ -37862,11 +37862,11 @@ func NewCube_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *Cube_listContext) GetParser() antlr.Parser { return s.parser } func (s *Cube_listContext) CUBE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCUBE, 0) + return s.GetToken(YQLParserCUBE, 0) } func (s *Cube_listContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Cube_listContext) Ordinary_grouping_set_list() IOrdinary_grouping_set_listContext { @@ -37886,7 +37886,7 @@ func (s *Cube_listContext) Ordinary_grouping_set_list() IOrdinary_grouping_set_l } func (s *Cube_listContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Cube_listContext) GetRuleContext() antlr.RuleContext { @@ -37899,13 +37899,13 @@ func (s *Cube_listContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Cube_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCube_list(s) } } func (s *Cube_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCube_list(s) } } @@ -37913,13 +37913,13 @@ func (s *Cube_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Cube_list() (localctx ICube_listContext) { +func (p *YQLParser) Cube_list() (localctx ICube_listContext) { localctx = NewCube_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 330, YQLv1Antlr4ParserRULE_cube_list) + p.EnterRule(localctx, 330, YQLParserRULE_cube_list) p.EnterOuterAlt(localctx, 1) { p.SetState(2451) - p.Match(YQLv1Antlr4ParserCUBE) + p.Match(YQLParserCUBE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37927,7 +37927,7 @@ func (p *YQLv1Antlr4Parser) Cube_list() (localctx ICube_listContext) { } { p.SetState(2452) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37939,7 +37939,7 @@ func (p *YQLv1Antlr4Parser) Cube_list() (localctx ICube_listContext) { } { p.SetState(2454) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37988,13 +37988,13 @@ type Grouping_sets_specificationContext struct { func NewEmptyGrouping_sets_specificationContext() *Grouping_sets_specificationContext { var p = new(Grouping_sets_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_sets_specification + p.RuleIndex = YQLParserRULE_grouping_sets_specification return p } func InitEmptyGrouping_sets_specificationContext(p *Grouping_sets_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_sets_specification + p.RuleIndex = YQLParserRULE_grouping_sets_specification } func (*Grouping_sets_specificationContext) IsGrouping_sets_specificationContext() {} @@ -38005,7 +38005,7 @@ func NewGrouping_sets_specificationContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_grouping_sets_specification + p.RuleIndex = YQLParserRULE_grouping_sets_specification return p } @@ -38013,15 +38013,15 @@ func NewGrouping_sets_specificationContext(parser antlr.Parser, parent antlr.Par func (s *Grouping_sets_specificationContext) GetParser() antlr.Parser { return s.parser } func (s *Grouping_sets_specificationContext) GROUPING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUPING, 0) + return s.GetToken(YQLParserGROUPING, 0) } func (s *Grouping_sets_specificationContext) SETS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSETS, 0) + return s.GetToken(YQLParserSETS, 0) } func (s *Grouping_sets_specificationContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Grouping_sets_specificationContext) Grouping_element_list() IGrouping_element_listContext { @@ -38041,7 +38041,7 @@ func (s *Grouping_sets_specificationContext) Grouping_element_list() IGrouping_e } func (s *Grouping_sets_specificationContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Grouping_sets_specificationContext) GetRuleContext() antlr.RuleContext { @@ -38054,13 +38054,13 @@ func (s *Grouping_sets_specificationContext) ToStringTree(ruleNames []string, re func (s *Grouping_sets_specificationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterGrouping_sets_specification(s) } } func (s *Grouping_sets_specificationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitGrouping_sets_specification(s) } } @@ -38068,13 +38068,13 @@ func (s *Grouping_sets_specificationContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Grouping_sets_specification() (localctx IGrouping_sets_specificationContext) { +func (p *YQLParser) Grouping_sets_specification() (localctx IGrouping_sets_specificationContext) { localctx = NewGrouping_sets_specificationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 332, YQLv1Antlr4ParserRULE_grouping_sets_specification) + p.EnterRule(localctx, 332, YQLParserRULE_grouping_sets_specification) p.EnterOuterAlt(localctx, 1) { p.SetState(2456) - p.Match(YQLv1Antlr4ParserGROUPING) + p.Match(YQLParserGROUPING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38082,7 +38082,7 @@ func (p *YQLv1Antlr4Parser) Grouping_sets_specification() (localctx IGrouping_se } { p.SetState(2457) - p.Match(YQLv1Antlr4ParserSETS) + p.Match(YQLParserSETS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38090,7 +38090,7 @@ func (p *YQLv1Antlr4Parser) Grouping_sets_specification() (localctx IGrouping_se } { p.SetState(2458) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38102,7 +38102,7 @@ func (p *YQLv1Antlr4Parser) Grouping_sets_specification() (localctx IGrouping_se } { p.SetState(2460) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38153,13 +38153,13 @@ type Hopping_window_specificationContext struct { func NewEmptyHopping_window_specificationContext() *Hopping_window_specificationContext { var p = new(Hopping_window_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_hopping_window_specification + p.RuleIndex = YQLParserRULE_hopping_window_specification return p } func InitEmptyHopping_window_specificationContext(p *Hopping_window_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_hopping_window_specification + p.RuleIndex = YQLParserRULE_hopping_window_specification } func (*Hopping_window_specificationContext) IsHopping_window_specificationContext() {} @@ -38170,7 +38170,7 @@ func NewHopping_window_specificationContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_hopping_window_specification + p.RuleIndex = YQLParserRULE_hopping_window_specification return p } @@ -38178,11 +38178,11 @@ func NewHopping_window_specificationContext(parser antlr.Parser, parent antlr.Pa func (s *Hopping_window_specificationContext) GetParser() antlr.Parser { return s.parser } func (s *Hopping_window_specificationContext) HOP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHOP, 0) + return s.GetToken(YQLParserHOP, 0) } func (s *Hopping_window_specificationContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Hopping_window_specificationContext) AllExpr() []IExprContext { @@ -38227,15 +38227,15 @@ func (s *Hopping_window_specificationContext) Expr(i int) IExprContext { } func (s *Hopping_window_specificationContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Hopping_window_specificationContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Hopping_window_specificationContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Hopping_window_specificationContext) GetRuleContext() antlr.RuleContext { @@ -38248,13 +38248,13 @@ func (s *Hopping_window_specificationContext) ToStringTree(ruleNames []string, r func (s *Hopping_window_specificationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterHopping_window_specification(s) } } func (s *Hopping_window_specificationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitHopping_window_specification(s) } } @@ -38262,13 +38262,13 @@ func (s *Hopping_window_specificationContext) ExitRule(listener antlr.ParseTreeL -func (p *YQLv1Antlr4Parser) Hopping_window_specification() (localctx IHopping_window_specificationContext) { +func (p *YQLParser) Hopping_window_specification() (localctx IHopping_window_specificationContext) { localctx = NewHopping_window_specificationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 334, YQLv1Antlr4ParserRULE_hopping_window_specification) + p.EnterRule(localctx, 334, YQLParserRULE_hopping_window_specification) p.EnterOuterAlt(localctx, 1) { p.SetState(2462) - p.Match(YQLv1Antlr4ParserHOP) + p.Match(YQLParserHOP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38276,7 +38276,7 @@ func (p *YQLv1Antlr4Parser) Hopping_window_specification() (localctx IHopping_wi } { p.SetState(2463) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38288,7 +38288,7 @@ func (p *YQLv1Antlr4Parser) Hopping_window_specification() (localctx IHopping_wi } { p.SetState(2465) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38300,7 +38300,7 @@ func (p *YQLv1Antlr4Parser) Hopping_window_specification() (localctx IHopping_wi } { p.SetState(2467) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38312,7 +38312,7 @@ func (p *YQLv1Antlr4Parser) Hopping_window_specification() (localctx IHopping_wi } { p.SetState(2469) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38324,7 +38324,7 @@ func (p *YQLv1Antlr4Parser) Hopping_window_specification() (localctx IHopping_wi } { p.SetState(2471) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38374,13 +38374,13 @@ type Result_columnContext struct { func NewEmptyResult_columnContext() *Result_columnContext { var p = new(Result_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_result_column + p.RuleIndex = YQLParserRULE_result_column return p } func InitEmptyResult_columnContext(p *Result_columnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_result_column + p.RuleIndex = YQLParserRULE_result_column } func (*Result_columnContext) IsResult_columnContext() {} @@ -38391,7 +38391,7 @@ func NewResult_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_result_column + p.RuleIndex = YQLParserRULE_result_column return p } @@ -38415,7 +38415,7 @@ func (s *Result_columnContext) Opt_id_prefix() IOpt_id_prefixContext { } func (s *Result_columnContext) ASTERISK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASTERISK, 0) + return s.GetToken(YQLParserASTERISK, 0) } func (s *Result_columnContext) Expr() IExprContext { @@ -38435,7 +38435,7 @@ func (s *Result_columnContext) Expr() IExprContext { } func (s *Result_columnContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Result_columnContext) An_id_or_type() IAn_id_or_typeContext { @@ -38480,13 +38480,13 @@ func (s *Result_columnContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Result_columnContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterResult_column(s) } } func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitResult_column(s) } } @@ -38494,9 +38494,9 @@ func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Result_column() (localctx IResult_columnContext) { +func (p *YQLParser) Result_column() (localctx IResult_columnContext) { localctx = NewResult_columnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 336, YQLv1Antlr4ParserRULE_result_column) + p.EnterRule(localctx, 336, YQLParserRULE_result_column) p.SetState(2482) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -38512,7 +38512,7 @@ func (p *YQLv1Antlr4Parser) Result_column() (localctx IResult_columnContext) { } { p.SetState(2474) - p.Match(YQLv1Antlr4ParserASTERISK) + p.Match(YQLParserASTERISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38533,7 +38533,7 @@ func (p *YQLv1Antlr4Parser) Result_column() (localctx IResult_columnContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 223, p.GetParserRuleContext()) == 1 { { p.SetState(2477) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38603,13 +38603,13 @@ type Join_sourceContext struct { func NewEmptyJoin_sourceContext() *Join_sourceContext { var p = new(Join_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_join_source + p.RuleIndex = YQLParserRULE_join_source return p } func InitEmptyJoin_sourceContext(p *Join_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_join_source + p.RuleIndex = YQLParserRULE_join_source } func (*Join_sourceContext) IsJoin_sourceContext() {} @@ -38620,7 +38620,7 @@ func NewJoin_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_join_source + p.RuleIndex = YQLParserRULE_join_source return p } @@ -38669,11 +38669,11 @@ func (s *Join_sourceContext) Flatten_source(i int) IFlatten_sourceContext { } func (s *Join_sourceContext) AllANY() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserANY) + return s.GetTokens(YQLParserANY) } func (s *Join_sourceContext) ANY(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANY, i) + return s.GetToken(YQLParserANY, i) } func (s *Join_sourceContext) AllJoin_op() []IJoin_opContext { @@ -38768,13 +38768,13 @@ func (s *Join_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Join_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJoin_source(s) } } func (s *Join_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJoin_source(s) } } @@ -38782,9 +38782,9 @@ func (s *Join_sourceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Join_source() (localctx IJoin_sourceContext) { +func (p *YQLParser) Join_source() (localctx IJoin_sourceContext) { localctx = NewJoin_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 338, YQLv1Antlr4ParserRULE_join_source) + p.EnterRule(localctx, 338, YQLParserRULE_join_source) var _la int p.EnterOuterAlt(localctx, 1) @@ -38795,7 +38795,7 @@ func (p *YQLv1Antlr4Parser) Join_source() (localctx IJoin_sourceContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 225, p.GetParserRuleContext()) == 1 { { p.SetState(2484) - p.Match(YQLv1Antlr4ParserANY) + p.Match(YQLParserANY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38817,7 +38817,7 @@ func (p *YQLv1Antlr4Parser) Join_source() (localctx IJoin_sourceContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA || _la == YQLv1Antlr4ParserCROSS || ((int64((_la - 124)) & ^0x3f) == 0 && ((int64(1) << (_la - 124)) & 18298072509579265) != 0) || ((int64((_la - 194)) & ^0x3f) == 0 && ((int64(1) << (_la - 194)) & -9223372036853727231) != 0) { + for _la == YQLParserCOMMA || _la == YQLParserCROSS || ((int64((_la - 124)) & ^0x3f) == 0 && ((int64(1) << (_la - 124)) & 18298072509579265) != 0) || ((int64((_la - 194)) & ^0x3f) == 0 && ((int64(1) << (_la - 194)) & -9223372036853727231) != 0) { { p.SetState(2488) p.Join_op() @@ -38829,7 +38829,7 @@ func (p *YQLv1Antlr4Parser) Join_source() (localctx IJoin_sourceContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 226, p.GetParserRuleContext()) == 1 { { p.SetState(2489) - p.Match(YQLv1Antlr4ParserANY) + p.Match(YQLParserANY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38851,7 +38851,7 @@ func (p *YQLv1Antlr4Parser) Join_source() (localctx IJoin_sourceContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserON || _la == YQLv1Antlr4ParserUSING { + if _la == YQLParserON || _la == YQLParserUSING { { p.SetState(2493) p.Join_constraint() @@ -38908,13 +38908,13 @@ type Named_columnContext struct { func NewEmptyNamed_columnContext() *Named_columnContext { var p = new(Named_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_column + p.RuleIndex = YQLParserRULE_named_column return p } func InitEmptyNamed_columnContext(p *Named_columnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_column + p.RuleIndex = YQLParserRULE_named_column } func (*Named_columnContext) IsNamed_columnContext() {} @@ -38925,7 +38925,7 @@ func NewNamed_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_named_column + p.RuleIndex = YQLParserRULE_named_column return p } @@ -38949,7 +38949,7 @@ func (s *Named_columnContext) Column_name() IColumn_nameContext { } func (s *Named_columnContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Named_columnContext) An_id() IAn_idContext { @@ -38978,13 +38978,13 @@ func (s *Named_columnContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Named_columnContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNamed_column(s) } } func (s *Named_columnContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNamed_column(s) } } @@ -38992,9 +38992,9 @@ func (s *Named_columnContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Named_column() (localctx INamed_columnContext) { +func (p *YQLParser) Named_column() (localctx INamed_columnContext) { localctx = NewNamed_columnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 340, YQLv1Antlr4ParserRULE_named_column) + p.EnterRule(localctx, 340, YQLParserRULE_named_column) var _la int p.EnterOuterAlt(localctx, 1) @@ -39010,10 +39010,10 @@ func (p *YQLv1Antlr4Parser) Named_column() (localctx INamed_columnContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAS { + if _la == YQLParserAS { { p.SetState(2502) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39068,13 +39068,13 @@ type Flatten_by_argContext struct { func NewEmptyFlatten_by_argContext() *Flatten_by_argContext { var p = new(Flatten_by_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_flatten_by_arg + p.RuleIndex = YQLParserRULE_flatten_by_arg return p } func InitEmptyFlatten_by_argContext(p *Flatten_by_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_flatten_by_arg + p.RuleIndex = YQLParserRULE_flatten_by_arg } func (*Flatten_by_argContext) IsFlatten_by_argContext() {} @@ -39085,7 +39085,7 @@ func NewFlatten_by_argContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_flatten_by_arg + p.RuleIndex = YQLParserRULE_flatten_by_arg return p } @@ -39109,7 +39109,7 @@ func (s *Flatten_by_argContext) Named_column() INamed_columnContext { } func (s *Flatten_by_argContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Flatten_by_argContext) Named_expr_list() INamed_expr_listContext { @@ -39129,11 +39129,11 @@ func (s *Flatten_by_argContext) Named_expr_list() INamed_expr_listContext { } func (s *Flatten_by_argContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Flatten_by_argContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Flatten_by_argContext) GetRuleContext() antlr.RuleContext { @@ -39146,13 +39146,13 @@ func (s *Flatten_by_argContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Flatten_by_argContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFlatten_by_arg(s) } } func (s *Flatten_by_argContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFlatten_by_arg(s) } } @@ -39160,9 +39160,9 @@ func (s *Flatten_by_argContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Flatten_by_arg() (localctx IFlatten_by_argContext) { +func (p *YQLParser) Flatten_by_arg() (localctx IFlatten_by_argContext) { localctx = NewFlatten_by_argContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 342, YQLv1Antlr4ParserRULE_flatten_by_arg) + p.EnterRule(localctx, 342, YQLParserRULE_flatten_by_arg) var _la int p.SetState(2514) @@ -39172,7 +39172,7 @@ func (p *YQLv1Antlr4Parser) Flatten_by_arg() (localctx IFlatten_by_argContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(2506) @@ -39180,11 +39180,11 @@ func (p *YQLv1Antlr4Parser) Flatten_by_arg() (localctx IFlatten_by_argContext) { } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(2507) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39202,10 +39202,10 @@ func (p *YQLv1Antlr4Parser) Flatten_by_arg() (localctx IFlatten_by_argContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(2509) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39215,7 +39215,7 @@ func (p *YQLv1Antlr4Parser) Flatten_by_arg() (localctx IFlatten_by_argContext) { } { p.SetState(2512) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39273,13 +39273,13 @@ type Flatten_sourceContext struct { func NewEmptyFlatten_sourceContext() *Flatten_sourceContext { var p = new(Flatten_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_flatten_source + p.RuleIndex = YQLParserRULE_flatten_source return p } func InitEmptyFlatten_sourceContext(p *Flatten_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_flatten_source + p.RuleIndex = YQLParserRULE_flatten_source } func (*Flatten_sourceContext) IsFlatten_sourceContext() {} @@ -39290,7 +39290,7 @@ func NewFlatten_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_flatten_source + p.RuleIndex = YQLParserRULE_flatten_source return p } @@ -39314,11 +39314,11 @@ func (s *Flatten_sourceContext) Named_single_source() INamed_single_sourceContex } func (s *Flatten_sourceContext) FLATTEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFLATTEN, 0) + return s.GetToken(YQLParserFLATTEN, 0) } func (s *Flatten_sourceContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Flatten_sourceContext) Flatten_by_arg() IFlatten_by_argContext { @@ -39338,19 +39338,19 @@ func (s *Flatten_sourceContext) Flatten_by_arg() IFlatten_by_argContext { } func (s *Flatten_sourceContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMNS, 0) + return s.GetToken(YQLParserCOLUMNS, 0) } func (s *Flatten_sourceContext) OPTIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOPTIONAL, 0) + return s.GetToken(YQLParserOPTIONAL, 0) } func (s *Flatten_sourceContext) LIST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIST, 0) + return s.GetToken(YQLParserLIST, 0) } func (s *Flatten_sourceContext) DICT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDICT, 0) + return s.GetToken(YQLParserDICT, 0) } func (s *Flatten_sourceContext) GetRuleContext() antlr.RuleContext { @@ -39363,13 +39363,13 @@ func (s *Flatten_sourceContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Flatten_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFlatten_source(s) } } func (s *Flatten_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFlatten_source(s) } } @@ -39377,9 +39377,9 @@ func (s *Flatten_sourceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Flatten_source() (localctx IFlatten_sourceContext) { +func (p *YQLParser) Flatten_source() (localctx IFlatten_sourceContext) { localctx = NewFlatten_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 344, YQLv1Antlr4ParserRULE_flatten_source) + p.EnterRule(localctx, 344, YQLParserRULE_flatten_source) var _la int p.EnterOuterAlt(localctx, 1) @@ -39395,10 +39395,10 @@ func (p *YQLv1Antlr4Parser) Flatten_source() (localctx IFlatten_sourceContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserFLATTEN { + if _la == YQLParserFLATTEN { { p.SetState(2517) - p.Match(YQLv1Antlr4ParserFLATTEN) + p.Match(YQLParserFLATTEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39411,7 +39411,7 @@ func (p *YQLv1Antlr4Parser) Flatten_source() (localctx IFlatten_sourceContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserBY, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserOPTIONAL: + case YQLParserBY, YQLParserDICT, YQLParserLIST, YQLParserOPTIONAL: p.SetState(2519) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -39420,12 +39420,12 @@ func (p *YQLv1Antlr4Parser) Flatten_source() (localctx IFlatten_sourceContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDICT || _la == YQLv1Antlr4ParserLIST || _la == YQLv1Antlr4ParserOPTIONAL { + if _la == YQLParserDICT || _la == YQLParserLIST || _la == YQLParserOPTIONAL { { p.SetState(2518) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserDICT || _la == YQLv1Antlr4ParserLIST || _la == YQLv1Antlr4ParserOPTIONAL) { + if !(_la == YQLParserDICT || _la == YQLParserLIST || _la == YQLParserOPTIONAL) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -39436,7 +39436,7 @@ func (p *YQLv1Antlr4Parser) Flatten_source() (localctx IFlatten_sourceContext) { } { p.SetState(2521) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39448,10 +39448,10 @@ func (p *YQLv1Antlr4Parser) Flatten_source() (localctx IFlatten_sourceContext) { } - case YQLv1Antlr4ParserCOLUMNS: + case YQLParserCOLUMNS: { p.SetState(2523) - p.Match(YQLv1Antlr4ParserCOLUMNS) + p.Match(YQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39512,13 +39512,13 @@ type Named_single_sourceContext struct { func NewEmptyNamed_single_sourceContext() *Named_single_sourceContext { var p = new(Named_single_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_single_source + p.RuleIndex = YQLParserRULE_named_single_source return p } func InitEmptyNamed_single_sourceContext(p *Named_single_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_single_source + p.RuleIndex = YQLParserRULE_named_single_source } func (*Named_single_sourceContext) IsNamed_single_sourceContext() {} @@ -39529,7 +39529,7 @@ func NewNamed_single_sourceContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_named_single_source + p.RuleIndex = YQLParserRULE_named_single_source return p } @@ -39601,7 +39601,7 @@ func (s *Named_single_sourceContext) Tablesample_clause() ITablesample_clauseCon } func (s *Named_single_sourceContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Named_single_sourceContext) An_id() IAn_idContext { @@ -39662,13 +39662,13 @@ func (s *Named_single_sourceContext) ToStringTree(ruleNames []string, recog antl func (s *Named_single_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNamed_single_source(s) } } func (s *Named_single_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNamed_single_source(s) } } @@ -39676,9 +39676,9 @@ func (s *Named_single_sourceContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Named_single_source() (localctx INamed_single_sourceContext) { +func (p *YQLParser) Named_single_source() (localctx INamed_single_sourceContext) { localctx = NewNamed_single_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 346, YQLv1Antlr4ParserRULE_named_single_source) + p.EnterRule(localctx, 346, YQLParserRULE_named_single_source) var _la int p.EnterOuterAlt(localctx, 1) @@ -39711,10 +39711,10 @@ func (p *YQLv1Antlr4Parser) Named_single_source() (localctx INamed_single_source } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserAS: + case YQLParserAS: { p.SetState(2532) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39726,7 +39726,7 @@ func (p *YQLv1Antlr4Parser) Named_single_source() (localctx INamed_single_source } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserLAST, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserREVERT, YQLParserREVOKE, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserVACUUM, YQLParserVALUES, YQLParserVIRTUAL, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(2534) p.An_id_as_compat() @@ -39746,7 +39746,7 @@ func (p *YQLv1Antlr4Parser) Named_single_source() (localctx INamed_single_source _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLPAREN { + if _la == YQLParserLPAREN { { p.SetState(2537) p.Pure_column_list() @@ -39763,21 +39763,21 @@ func (p *YQLv1Antlr4Parser) Named_single_source() (localctx INamed_single_source goto errorExit } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSAMPLE: + case YQLParserSAMPLE: { p.SetState(2542) p.Sample_clause() } - case YQLv1Antlr4ParserTABLESAMPLE: + case YQLParserTABLESAMPLE: { p.SetState(2543) p.Tablesample_clause() } - case YQLv1Antlr4ParserEOF, YQLv1Antlr4ParserSEMICOLON, YQLv1Antlr4ParserCOMMA, YQLv1Antlr4ParserRPAREN, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserON, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW: + case YQLParserEOF, YQLParserSEMICOLON, YQLParserCOMMA, YQLParserRPAREN, YQLParserASSUME, YQLParserCROSS, YQLParserEND, YQLParserEXCEPT, YQLParserEXCLUSION, YQLParserFLATTEN, YQLParserFULL, YQLParserGROUP, YQLParserHAVING, YQLParserINNER, YQLParserINTERSECT, YQLParserINTO, YQLParserJOIN, YQLParserLEFT, YQLParserLIMIT, YQLParserNATURAL, YQLParserON, YQLParserORDER, YQLParserOUTER, YQLParserPRESORT, YQLParserRETURNING, YQLParserRIGHT, YQLParserSELECT, YQLParserUNION, YQLParserUSING, YQLParserWHERE, YQLParserWINDOW: @@ -39826,13 +39826,13 @@ type Single_sourceContext struct { func NewEmptySingle_sourceContext() *Single_sourceContext { var p = new(Single_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_single_source + p.RuleIndex = YQLParserRULE_single_source return p } func InitEmptySingle_sourceContext(p *Single_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_single_source + p.RuleIndex = YQLParserRULE_single_source } func (*Single_sourceContext) IsSingle_sourceContext() {} @@ -39843,7 +39843,7 @@ func NewSingle_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_single_source + p.RuleIndex = YQLParserRULE_single_source return p } @@ -39867,7 +39867,7 @@ func (s *Single_sourceContext) Table_ref() ITable_refContext { } func (s *Single_sourceContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Single_sourceContext) Select_stmt() ISelect_stmtContext { @@ -39887,7 +39887,7 @@ func (s *Single_sourceContext) Select_stmt() ISelect_stmtContext { } func (s *Single_sourceContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Single_sourceContext) Values_stmt() IValues_stmtContext { @@ -39916,13 +39916,13 @@ func (s *Single_sourceContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Single_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSingle_source(s) } } func (s *Single_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSingle_source(s) } } @@ -39930,9 +39930,9 @@ func (s *Single_sourceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Single_source() (localctx ISingle_sourceContext) { +func (p *YQLParser) Single_source() (localctx ISingle_sourceContext) { localctx = NewSingle_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 348, YQLv1Antlr4ParserRULE_single_source) + p.EnterRule(localctx, 348, YQLParserRULE_single_source) p.SetState(2555) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -39952,7 +39952,7 @@ func (p *YQLv1Antlr4Parser) Single_source() (localctx ISingle_sourceContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(2547) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39964,7 +39964,7 @@ func (p *YQLv1Antlr4Parser) Single_source() (localctx ISingle_sourceContext) { } { p.SetState(2549) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39976,7 +39976,7 @@ func (p *YQLv1Antlr4Parser) Single_source() (localctx ISingle_sourceContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(2551) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -39988,7 +39988,7 @@ func (p *YQLv1Antlr4Parser) Single_source() (localctx ISingle_sourceContext) { } { p.SetState(2553) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40037,13 +40037,13 @@ type Sample_clauseContext struct { func NewEmptySample_clauseContext() *Sample_clauseContext { var p = new(Sample_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sample_clause + p.RuleIndex = YQLParserRULE_sample_clause return p } func InitEmptySample_clauseContext(p *Sample_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sample_clause + p.RuleIndex = YQLParserRULE_sample_clause } func (*Sample_clauseContext) IsSample_clauseContext() {} @@ -40054,7 +40054,7 @@ func NewSample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sample_clause + p.RuleIndex = YQLParserRULE_sample_clause return p } @@ -40062,7 +40062,7 @@ func NewSample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Sample_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Sample_clauseContext) SAMPLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSAMPLE, 0) + return s.GetToken(YQLParserSAMPLE, 0) } func (s *Sample_clauseContext) Expr() IExprContext { @@ -40091,13 +40091,13 @@ func (s *Sample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Sample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSample_clause(s) } } func (s *Sample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSample_clause(s) } } @@ -40105,13 +40105,13 @@ func (s *Sample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Sample_clause() (localctx ISample_clauseContext) { +func (p *YQLParser) Sample_clause() (localctx ISample_clauseContext) { localctx = NewSample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 350, YQLv1Antlr4ParserRULE_sample_clause) + p.EnterRule(localctx, 350, YQLParserRULE_sample_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(2557) - p.Match(YQLv1Antlr4ParserSAMPLE) + p.Match(YQLParserSAMPLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40165,13 +40165,13 @@ type Tablesample_clauseContext struct { func NewEmptyTablesample_clauseContext() *Tablesample_clauseContext { var p = new(Tablesample_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_tablesample_clause + p.RuleIndex = YQLParserRULE_tablesample_clause return p } func InitEmptyTablesample_clauseContext(p *Tablesample_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_tablesample_clause + p.RuleIndex = YQLParserRULE_tablesample_clause } func (*Tablesample_clauseContext) IsTablesample_clauseContext() {} @@ -40182,7 +40182,7 @@ func NewTablesample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_tablesample_clause + p.RuleIndex = YQLParserRULE_tablesample_clause return p } @@ -40190,7 +40190,7 @@ func NewTablesample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Tablesample_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Tablesample_clauseContext) TABLESAMPLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESAMPLE, 0) + return s.GetToken(YQLParserTABLESAMPLE, 0) } func (s *Tablesample_clauseContext) Sampling_mode() ISampling_modeContext { @@ -40210,7 +40210,7 @@ func (s *Tablesample_clauseContext) Sampling_mode() ISampling_modeContext { } func (s *Tablesample_clauseContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Tablesample_clauseContext) Expr() IExprContext { @@ -40230,7 +40230,7 @@ func (s *Tablesample_clauseContext) Expr() IExprContext { } func (s *Tablesample_clauseContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Tablesample_clauseContext) Repeatable_clause() IRepeatable_clauseContext { @@ -40259,13 +40259,13 @@ func (s *Tablesample_clauseContext) ToStringTree(ruleNames []string, recog antlr func (s *Tablesample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTablesample_clause(s) } } func (s *Tablesample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTablesample_clause(s) } } @@ -40273,15 +40273,15 @@ func (s *Tablesample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Tablesample_clause() (localctx ITablesample_clauseContext) { +func (p *YQLParser) Tablesample_clause() (localctx ITablesample_clauseContext) { localctx = NewTablesample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 352, YQLv1Antlr4ParserRULE_tablesample_clause) + p.EnterRule(localctx, 352, YQLParserRULE_tablesample_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2560) - p.Match(YQLv1Antlr4ParserTABLESAMPLE) + p.Match(YQLParserTABLESAMPLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40293,7 +40293,7 @@ func (p *YQLv1Antlr4Parser) Tablesample_clause() (localctx ITablesample_clauseCo } { p.SetState(2562) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40305,7 +40305,7 @@ func (p *YQLv1Antlr4Parser) Tablesample_clause() (localctx ITablesample_clauseCo } { p.SetState(2564) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40319,7 +40319,7 @@ func (p *YQLv1Antlr4Parser) Tablesample_clause() (localctx ITablesample_clauseCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserREPEATABLE { + if _la == YQLParserREPEATABLE { { p.SetState(2565) p.Repeatable_clause() @@ -40366,13 +40366,13 @@ type Sampling_modeContext struct { func NewEmptySampling_modeContext() *Sampling_modeContext { var p = new(Sampling_modeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sampling_mode + p.RuleIndex = YQLParserRULE_sampling_mode return p } func InitEmptySampling_modeContext(p *Sampling_modeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_sampling_mode + p.RuleIndex = YQLParserRULE_sampling_mode } func (*Sampling_modeContext) IsSampling_modeContext() {} @@ -40383,7 +40383,7 @@ func NewSampling_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_sampling_mode + p.RuleIndex = YQLParserRULE_sampling_mode return p } @@ -40391,11 +40391,11 @@ func NewSampling_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Sampling_modeContext) GetParser() antlr.Parser { return s.parser } func (s *Sampling_modeContext) BERNOULLI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBERNOULLI, 0) + return s.GetToken(YQLParserBERNOULLI, 0) } func (s *Sampling_modeContext) SYSTEM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYSTEM, 0) + return s.GetToken(YQLParserSYSTEM, 0) } func (s *Sampling_modeContext) GetRuleContext() antlr.RuleContext { @@ -40408,13 +40408,13 @@ func (s *Sampling_modeContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Sampling_modeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSampling_mode(s) } } func (s *Sampling_modeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSampling_mode(s) } } @@ -40422,9 +40422,9 @@ func (s *Sampling_modeContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Sampling_mode() (localctx ISampling_modeContext) { +func (p *YQLParser) Sampling_mode() (localctx ISampling_modeContext) { localctx = NewSampling_modeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 354, YQLv1Antlr4ParserRULE_sampling_mode) + p.EnterRule(localctx, 354, YQLParserRULE_sampling_mode) var _la int p.EnterOuterAlt(localctx, 1) @@ -40432,7 +40432,7 @@ func (p *YQLv1Antlr4Parser) Sampling_mode() (localctx ISampling_modeContext) { p.SetState(2568) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserBERNOULLI || _la == YQLv1Antlr4ParserSYSTEM) { + if !(_la == YQLParserBERNOULLI || _la == YQLParserSYSTEM) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -40481,13 +40481,13 @@ type Repeatable_clauseContext struct { func NewEmptyRepeatable_clauseContext() *Repeatable_clauseContext { var p = new(Repeatable_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_repeatable_clause + p.RuleIndex = YQLParserRULE_repeatable_clause return p } func InitEmptyRepeatable_clauseContext(p *Repeatable_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_repeatable_clause + p.RuleIndex = YQLParserRULE_repeatable_clause } func (*Repeatable_clauseContext) IsRepeatable_clauseContext() {} @@ -40498,7 +40498,7 @@ func NewRepeatable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_repeatable_clause + p.RuleIndex = YQLParserRULE_repeatable_clause return p } @@ -40506,11 +40506,11 @@ func NewRepeatable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Repeatable_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Repeatable_clauseContext) REPEATABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPEATABLE, 0) + return s.GetToken(YQLParserREPEATABLE, 0) } func (s *Repeatable_clauseContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Repeatable_clauseContext) Expr() IExprContext { @@ -40530,7 +40530,7 @@ func (s *Repeatable_clauseContext) Expr() IExprContext { } func (s *Repeatable_clauseContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Repeatable_clauseContext) GetRuleContext() antlr.RuleContext { @@ -40543,13 +40543,13 @@ func (s *Repeatable_clauseContext) ToStringTree(ruleNames []string, recog antlr. func (s *Repeatable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRepeatable_clause(s) } } func (s *Repeatable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRepeatable_clause(s) } } @@ -40557,13 +40557,13 @@ func (s *Repeatable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Repeatable_clause() (localctx IRepeatable_clauseContext) { +func (p *YQLParser) Repeatable_clause() (localctx IRepeatable_clauseContext) { localctx = NewRepeatable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 356, YQLv1Antlr4ParserRULE_repeatable_clause) + p.EnterRule(localctx, 356, YQLParserRULE_repeatable_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(2570) - p.Match(YQLv1Antlr4ParserREPEATABLE) + p.Match(YQLParserREPEATABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40571,7 +40571,7 @@ func (p *YQLv1Antlr4Parser) Repeatable_clause() (localctx IRepeatable_clauseCont } { p.SetState(2571) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40583,7 +40583,7 @@ func (p *YQLv1Antlr4Parser) Repeatable_clause() (localctx IRepeatable_clauseCont } { p.SetState(2573) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40639,13 +40639,13 @@ type Join_opContext struct { func NewEmptyJoin_opContext() *Join_opContext { var p = new(Join_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_join_op + p.RuleIndex = YQLParserRULE_join_op return p } func InitEmptyJoin_opContext(p *Join_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_join_op + p.RuleIndex = YQLParserRULE_join_op } func (*Join_opContext) IsJoin_opContext() {} @@ -40656,7 +40656,7 @@ func NewJoin_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_join_op + p.RuleIndex = YQLParserRULE_join_op return p } @@ -40664,51 +40664,51 @@ func NewJoin_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *Join_opContext) GetParser() antlr.Parser { return s.parser } func (s *Join_opContext) COMMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, 0) + return s.GetToken(YQLParserCOMMA, 0) } func (s *Join_opContext) JOIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJOIN, 0) + return s.GetToken(YQLParserJOIN, 0) } func (s *Join_opContext) INNER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINNER, 0) + return s.GetToken(YQLParserINNER, 0) } func (s *Join_opContext) CROSS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCROSS, 0) + return s.GetToken(YQLParserCROSS, 0) } func (s *Join_opContext) NATURAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNATURAL, 0) + return s.GetToken(YQLParserNATURAL, 0) } func (s *Join_opContext) LEFT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLEFT, 0) + return s.GetToken(YQLParserLEFT, 0) } func (s *Join_opContext) RIGHT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRIGHT, 0) + return s.GetToken(YQLParserRIGHT, 0) } func (s *Join_opContext) EXCLUSION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCLUSION, 0) + return s.GetToken(YQLParserEXCLUSION, 0) } func (s *Join_opContext) FULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFULL, 0) + return s.GetToken(YQLParserFULL, 0) } func (s *Join_opContext) OUTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOUTER, 0) + return s.GetToken(YQLParserOUTER, 0) } func (s *Join_opContext) ONLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserONLY, 0) + return s.GetToken(YQLParserONLY, 0) } func (s *Join_opContext) SEMI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEMI, 0) + return s.GetToken(YQLParserSEMI, 0) } func (s *Join_opContext) GetRuleContext() antlr.RuleContext { @@ -40721,13 +40721,13 @@ func (s *Join_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *Join_opContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJoin_op(s) } } func (s *Join_opContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJoin_op(s) } } @@ -40735,9 +40735,9 @@ func (s *Join_opContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { +func (p *YQLParser) Join_op() (localctx IJoin_opContext) { localctx = NewJoin_opContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 358, YQLv1Antlr4ParserRULE_join_op) + p.EnterRule(localctx, 358, YQLParserRULE_join_op) var _la int p.SetState(2599) @@ -40747,11 +40747,11 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserCOMMA: + case YQLParserCOMMA: p.EnterOuterAlt(localctx, 1) { p.SetState(2575) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40759,7 +40759,7 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } - case YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserRIGHT: + case YQLParserCROSS, YQLParserEXCLUSION, YQLParserFULL, YQLParserINNER, YQLParserJOIN, YQLParserLEFT, YQLParserNATURAL, YQLParserOUTER, YQLParserRIGHT: p.EnterOuterAlt(localctx, 2) p.SetState(2577) p.GetErrorHandler().Sync(p) @@ -40769,10 +40769,10 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNATURAL { + if _la == YQLParserNATURAL { { p.SetState(2576) - p.Match(YQLv1Antlr4ParserNATURAL) + p.Match(YQLParserNATURAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40787,17 +40787,17 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserRIGHT: + case YQLParserEXCLUSION, YQLParserFULL, YQLParserJOIN, YQLParserLEFT, YQLParserOUTER, YQLParserRIGHT: p.SetState(2589) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLEFT: + case YQLParserLEFT: { p.SetState(2579) - p.Match(YQLv1Antlr4ParserLEFT) + p.Match(YQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40811,12 +40811,12 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserONLY || _la == YQLv1Antlr4ParserSEMI { + if _la == YQLParserONLY || _la == YQLParserSEMI { { p.SetState(2580) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserONLY || _la == YQLv1Antlr4ParserSEMI) { + if !(_la == YQLParserONLY || _la == YQLParserSEMI) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -40827,10 +40827,10 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } - case YQLv1Antlr4ParserRIGHT: + case YQLParserRIGHT: { p.SetState(2583) - p.Match(YQLv1Antlr4ParserRIGHT) + p.Match(YQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40844,12 +40844,12 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserONLY || _la == YQLv1Antlr4ParserSEMI { + if _la == YQLParserONLY || _la == YQLParserSEMI { { p.SetState(2584) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserONLY || _la == YQLv1Antlr4ParserSEMI) { + if !(_la == YQLParserONLY || _la == YQLParserSEMI) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -40860,10 +40860,10 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } - case YQLv1Antlr4ParserEXCLUSION: + case YQLParserEXCLUSION: { p.SetState(2587) - p.Match(YQLv1Antlr4ParserEXCLUSION) + p.Match(YQLParserEXCLUSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40871,10 +40871,10 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } - case YQLv1Antlr4ParserFULL: + case YQLParserFULL: { p.SetState(2588) - p.Match(YQLv1Antlr4ParserFULL) + p.Match(YQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40882,7 +40882,7 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } - case YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserOUTER: + case YQLParserJOIN, YQLParserOUTER: @@ -40896,10 +40896,10 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserOUTER { + if _la == YQLParserOUTER { { p.SetState(2591) - p.Match(YQLv1Antlr4ParserOUTER) + p.Match(YQLParserOUTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40909,10 +40909,10 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } - case YQLv1Antlr4ParserINNER: + case YQLParserINNER: { p.SetState(2594) - p.Match(YQLv1Antlr4ParserINNER) + p.Match(YQLParserINNER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40920,10 +40920,10 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } - case YQLv1Antlr4ParserCROSS: + case YQLParserCROSS: { p.SetState(2595) - p.Match(YQLv1Antlr4ParserCROSS) + p.Match(YQLParserCROSS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40938,7 +40938,7 @@ func (p *YQLv1Antlr4Parser) Join_op() (localctx IJoin_opContext) { } { p.SetState(2598) - p.Match(YQLv1Antlr4ParserJOIN) + p.Match(YQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40992,13 +40992,13 @@ type Join_constraintContext struct { func NewEmptyJoin_constraintContext() *Join_constraintContext { var p = new(Join_constraintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_join_constraint + p.RuleIndex = YQLParserRULE_join_constraint return p } func InitEmptyJoin_constraintContext(p *Join_constraintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_join_constraint + p.RuleIndex = YQLParserRULE_join_constraint } func (*Join_constraintContext) IsJoin_constraintContext() {} @@ -41009,7 +41009,7 @@ func NewJoin_constraintContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_join_constraint + p.RuleIndex = YQLParserRULE_join_constraint return p } @@ -41017,7 +41017,7 @@ func NewJoin_constraintContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Join_constraintContext) GetParser() antlr.Parser { return s.parser } func (s *Join_constraintContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Join_constraintContext) Expr() IExprContext { @@ -41037,7 +41037,7 @@ func (s *Join_constraintContext) Expr() IExprContext { } func (s *Join_constraintContext) USING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSING, 0) + return s.GetToken(YQLParserUSING, 0) } func (s *Join_constraintContext) Pure_column_or_named_list() IPure_column_or_named_listContext { @@ -41066,13 +41066,13 @@ func (s *Join_constraintContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Join_constraintContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterJoin_constraint(s) } } func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitJoin_constraint(s) } } @@ -41080,9 +41080,9 @@ func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Join_constraint() (localctx IJoin_constraintContext) { +func (p *YQLParser) Join_constraint() (localctx IJoin_constraintContext) { localctx = NewJoin_constraintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 360, YQLv1Antlr4ParserRULE_join_constraint) + p.EnterRule(localctx, 360, YQLParserRULE_join_constraint) p.SetState(2605) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -41090,11 +41090,11 @@ func (p *YQLv1Antlr4Parser) Join_constraint() (localctx IJoin_constraintContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserON: + case YQLParserON: p.EnterOuterAlt(localctx, 1) { p.SetState(2601) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41106,11 +41106,11 @@ func (p *YQLv1Antlr4Parser) Join_constraint() (localctx IJoin_constraintContext) } - case YQLv1Antlr4ParserUSING: + case YQLParserUSING: p.EnterOuterAlt(localctx, 2) { p.SetState(2603) - p.Match(YQLv1Antlr4ParserUSING) + p.Match(YQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41170,13 +41170,13 @@ type Returning_columns_listContext struct { func NewEmptyReturning_columns_listContext() *Returning_columns_listContext { var p = new(Returning_columns_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_returning_columns_list + p.RuleIndex = YQLParserRULE_returning_columns_list return p } func InitEmptyReturning_columns_listContext(p *Returning_columns_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_returning_columns_list + p.RuleIndex = YQLParserRULE_returning_columns_list } func (*Returning_columns_listContext) IsReturning_columns_listContext() {} @@ -41187,7 +41187,7 @@ func NewReturning_columns_listContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_returning_columns_list + p.RuleIndex = YQLParserRULE_returning_columns_list return p } @@ -41195,11 +41195,11 @@ func NewReturning_columns_listContext(parser antlr.Parser, parent antlr.ParserRu func (s *Returning_columns_listContext) GetParser() antlr.Parser { return s.parser } func (s *Returning_columns_listContext) RETURNING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRETURNING, 0) + return s.GetToken(YQLParserRETURNING, 0) } func (s *Returning_columns_listContext) ASTERISK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASTERISK, 0) + return s.GetToken(YQLParserASTERISK, 0) } func (s *Returning_columns_listContext) AllAn_id() []IAn_idContext { @@ -41244,11 +41244,11 @@ func (s *Returning_columns_listContext) An_id(i int) IAn_idContext { } func (s *Returning_columns_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Returning_columns_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Returning_columns_listContext) GetRuleContext() antlr.RuleContext { @@ -41261,13 +41261,13 @@ func (s *Returning_columns_listContext) ToStringTree(ruleNames []string, recog a func (s *Returning_columns_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterReturning_columns_list(s) } } func (s *Returning_columns_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitReturning_columns_list(s) } } @@ -41275,15 +41275,15 @@ func (s *Returning_columns_listContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Returning_columns_list() (localctx IReturning_columns_listContext) { +func (p *YQLParser) Returning_columns_list() (localctx IReturning_columns_listContext) { localctx = NewReturning_columns_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 362, YQLv1Antlr4ParserRULE_returning_columns_list) + p.EnterRule(localctx, 362, YQLParserRULE_returning_columns_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2607) - p.Match(YQLv1Antlr4ParserRETURNING) + p.Match(YQLParserRETURNING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41296,10 +41296,10 @@ func (p *YQLv1Antlr4Parser) Returning_columns_list() (localctx IReturning_column } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserASTERISK: + case YQLParserASTERISK: { p.SetState(2608) - p.Match(YQLv1Antlr4ParserASTERISK) + p.Match(YQLParserASTERISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41307,7 +41307,7 @@ func (p *YQLv1Antlr4Parser) Returning_columns_list() (localctx IReturning_column } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(2609) p.An_id() @@ -41320,10 +41320,10 @@ func (p *YQLv1Antlr4Parser) Returning_columns_list() (localctx IReturning_column _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2610) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41398,13 +41398,13 @@ type Into_table_stmtContext struct { func NewEmptyInto_table_stmtContext() *Into_table_stmtContext { var p = new(Into_table_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_into_table_stmt + p.RuleIndex = YQLParserRULE_into_table_stmt return p } func InitEmptyInto_table_stmtContext(p *Into_table_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_into_table_stmt + p.RuleIndex = YQLParserRULE_into_table_stmt } func (*Into_table_stmtContext) IsInto_table_stmtContext() {} @@ -41415,7 +41415,7 @@ func NewInto_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_into_table_stmt + p.RuleIndex = YQLParserRULE_into_table_stmt return p } @@ -41423,7 +41423,7 @@ func NewInto_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Into_table_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Into_table_stmtContext) INTO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINTO, 0) + return s.GetToken(YQLParserINTO, 0) } func (s *Into_table_stmtContext) Into_simple_table_ref() IInto_simple_table_refContext { @@ -41459,31 +41459,31 @@ func (s *Into_table_stmtContext) Into_values_source() IInto_values_sourceContext } func (s *Into_table_stmtContext) INSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINSERT, 0) + return s.GetToken(YQLParserINSERT, 0) } func (s *Into_table_stmtContext) OR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOR, 0) + return s.GetToken(YQLParserOR, 0) } func (s *Into_table_stmtContext) ABORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserABORT, 0) + return s.GetToken(YQLParserABORT, 0) } func (s *Into_table_stmtContext) REVERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREVERT, 0) + return s.GetToken(YQLParserREVERT, 0) } func (s *Into_table_stmtContext) IGNORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIGNORE, 0) + return s.GetToken(YQLParserIGNORE, 0) } func (s *Into_table_stmtContext) UPSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPSERT, 0) + return s.GetToken(YQLParserUPSERT, 0) } func (s *Into_table_stmtContext) REPLACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLACE, 0) + return s.GetToken(YQLParserREPLACE, 0) } func (s *Into_table_stmtContext) Returning_columns_list() IReturning_columns_listContext { @@ -41512,13 +41512,13 @@ func (s *Into_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Into_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInto_table_stmt(s) } } func (s *Into_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInto_table_stmt(s) } } @@ -41526,9 +41526,9 @@ func (s *Into_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) { +func (p *YQLParser) Into_table_stmt() (localctx IInto_table_stmtContext) { localctx = NewInto_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 364, YQLv1Antlr4ParserRULE_into_table_stmt) + p.EnterRule(localctx, 364, YQLParserRULE_into_table_stmt) var _la int p.EnterOuterAlt(localctx, 1) @@ -41542,7 +41542,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) case 1: { p.SetState(2619) - p.Match(YQLv1Antlr4ParserINSERT) + p.Match(YQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41553,7 +41553,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) case 2: { p.SetState(2620) - p.Match(YQLv1Antlr4ParserINSERT) + p.Match(YQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41561,7 +41561,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) } { p.SetState(2621) - p.Match(YQLv1Antlr4ParserOR) + p.Match(YQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41569,7 +41569,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) } { p.SetState(2622) - p.Match(YQLv1Antlr4ParserABORT) + p.Match(YQLParserABORT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41580,7 +41580,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) case 3: { p.SetState(2623) - p.Match(YQLv1Antlr4ParserINSERT) + p.Match(YQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41588,7 +41588,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) } { p.SetState(2624) - p.Match(YQLv1Antlr4ParserOR) + p.Match(YQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41596,7 +41596,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) } { p.SetState(2625) - p.Match(YQLv1Antlr4ParserREVERT) + p.Match(YQLParserREVERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41607,7 +41607,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) case 4: { p.SetState(2626) - p.Match(YQLv1Antlr4ParserINSERT) + p.Match(YQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41615,7 +41615,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) } { p.SetState(2627) - p.Match(YQLv1Antlr4ParserOR) + p.Match(YQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41623,7 +41623,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) } { p.SetState(2628) - p.Match(YQLv1Antlr4ParserIGNORE) + p.Match(YQLParserIGNORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41634,7 +41634,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) case 5: { p.SetState(2629) - p.Match(YQLv1Antlr4ParserUPSERT) + p.Match(YQLParserUPSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41645,7 +41645,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) case 6: { p.SetState(2630) - p.Match(YQLv1Antlr4ParserREPLACE) + p.Match(YQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41657,7 +41657,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) } { p.SetState(2633) - p.Match(YQLv1Antlr4ParserINTO) + p.Match(YQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41679,7 +41679,7 @@ func (p *YQLv1Antlr4Parser) Into_table_stmt() (localctx IInto_table_stmtContext) _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserRETURNING { + if _la == YQLParserRETURNING { { p.SetState(2636) p.Returning_columns_list() @@ -41728,13 +41728,13 @@ type Into_values_sourceContext struct { func NewEmptyInto_values_sourceContext() *Into_values_sourceContext { var p = new(Into_values_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_into_values_source + p.RuleIndex = YQLParserRULE_into_values_source return p } func InitEmptyInto_values_sourceContext(p *Into_values_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_into_values_source + p.RuleIndex = YQLParserRULE_into_values_source } func (*Into_values_sourceContext) IsInto_values_sourceContext() {} @@ -41745,7 +41745,7 @@ func NewInto_values_sourceContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_into_values_source + p.RuleIndex = YQLParserRULE_into_values_source return p } @@ -41785,11 +41785,11 @@ func (s *Into_values_sourceContext) Pure_column_list() IPure_column_listContext } func (s *Into_values_sourceContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFAULT, 0) + return s.GetToken(YQLParserDEFAULT, 0) } func (s *Into_values_sourceContext) VALUES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVALUES, 0) + return s.GetToken(YQLParserVALUES, 0) } func (s *Into_values_sourceContext) GetRuleContext() antlr.RuleContext { @@ -41802,13 +41802,13 @@ func (s *Into_values_sourceContext) ToStringTree(ruleNames []string, recog antlr func (s *Into_values_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInto_values_source(s) } } func (s *Into_values_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInto_values_source(s) } } @@ -41816,9 +41816,9 @@ func (s *Into_values_sourceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Into_values_source() (localctx IInto_values_sourceContext) { +func (p *YQLParser) Into_values_source() (localctx IInto_values_sourceContext) { localctx = NewInto_values_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 366, YQLv1Antlr4ParserRULE_into_values_source) + p.EnterRule(localctx, 366, YQLParserRULE_into_values_source) p.SetState(2645) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -41826,7 +41826,7 @@ func (p *YQLv1Antlr4Parser) Into_values_source() (localctx IInto_values_sourceCo } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLPAREN, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserVALUES: + case YQLParserLPAREN, YQLParserDISCARD, YQLParserFROM, YQLParserPROCESS, YQLParserREDUCE, YQLParserSELECT, YQLParserVALUES: p.EnterOuterAlt(localctx, 1) p.SetState(2640) p.GetErrorHandler().Sync(p) @@ -41847,11 +41847,11 @@ func (p *YQLv1Antlr4Parser) Into_values_source() (localctx IInto_values_sourceCo } - case YQLv1Antlr4ParserDEFAULT: + case YQLParserDEFAULT: p.EnterOuterAlt(localctx, 2) { p.SetState(2643) - p.Match(YQLv1Antlr4ParserDEFAULT) + p.Match(YQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41859,7 +41859,7 @@ func (p *YQLv1Antlr4Parser) Into_values_source() (localctx IInto_values_sourceCo } { p.SetState(2644) - p.Match(YQLv1Antlr4ParserVALUES) + p.Match(YQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41911,13 +41911,13 @@ type Values_stmtContext struct { func NewEmptyValues_stmtContext() *Values_stmtContext { var p = new(Values_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_stmt + p.RuleIndex = YQLParserRULE_values_stmt return p } func InitEmptyValues_stmtContext(p *Values_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_stmt + p.RuleIndex = YQLParserRULE_values_stmt } func (*Values_stmtContext) IsValues_stmtContext() {} @@ -41928,7 +41928,7 @@ func NewValues_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_values_stmt + p.RuleIndex = YQLParserRULE_values_stmt return p } @@ -41936,7 +41936,7 @@ func NewValues_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Values_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Values_stmtContext) VALUES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVALUES, 0) + return s.GetToken(YQLParserVALUES, 0) } func (s *Values_stmtContext) Values_source_row_list() IValues_source_row_listContext { @@ -41965,13 +41965,13 @@ func (s *Values_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Values_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterValues_stmt(s) } } func (s *Values_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitValues_stmt(s) } } @@ -41979,13 +41979,13 @@ func (s *Values_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Values_stmt() (localctx IValues_stmtContext) { +func (p *YQLParser) Values_stmt() (localctx IValues_stmtContext) { localctx = NewValues_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 368, YQLv1Antlr4ParserRULE_values_stmt) + p.EnterRule(localctx, 368, YQLParserRULE_values_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2647) - p.Match(YQLv1Antlr4ParserVALUES) + p.Match(YQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42035,13 +42035,13 @@ type Values_sourceContext struct { func NewEmptyValues_sourceContext() *Values_sourceContext { var p = new(Values_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source + p.RuleIndex = YQLParserRULE_values_source return p } func InitEmptyValues_sourceContext(p *Values_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source + p.RuleIndex = YQLParserRULE_values_source } func (*Values_sourceContext) IsValues_sourceContext() {} @@ -42052,7 +42052,7 @@ func NewValues_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source + p.RuleIndex = YQLParserRULE_values_source return p } @@ -42101,13 +42101,13 @@ func (s *Values_sourceContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Values_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterValues_source(s) } } func (s *Values_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitValues_source(s) } } @@ -42115,9 +42115,9 @@ func (s *Values_sourceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Values_source() (localctx IValues_sourceContext) { +func (p *YQLParser) Values_source() (localctx IValues_sourceContext) { localctx = NewValues_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 370, YQLv1Antlr4ParserRULE_values_source) + p.EnterRule(localctx, 370, YQLParserRULE_values_source) p.SetState(2652) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -42125,7 +42125,7 @@ func (p *YQLv1Antlr4Parser) Values_source() (localctx IValues_sourceContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserVALUES: + case YQLParserVALUES: p.EnterOuterAlt(localctx, 1) { p.SetState(2650) @@ -42133,7 +42133,7 @@ func (p *YQLv1Antlr4Parser) Values_source() (localctx IValues_sourceContext) { } - case YQLv1Antlr4ParserLPAREN, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserSELECT: + case YQLParserLPAREN, YQLParserDISCARD, YQLParserFROM, YQLParserPROCESS, YQLParserREDUCE, YQLParserSELECT: p.EnterOuterAlt(localctx, 2) { p.SetState(2651) @@ -42187,13 +42187,13 @@ type Values_source_row_listContext struct { func NewEmptyValues_source_row_listContext() *Values_source_row_listContext { var p = new(Values_source_row_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source_row_list + p.RuleIndex = YQLParserRULE_values_source_row_list return p } func InitEmptyValues_source_row_listContext(p *Values_source_row_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source_row_list + p.RuleIndex = YQLParserRULE_values_source_row_list } func (*Values_source_row_listContext) IsValues_source_row_listContext() {} @@ -42204,7 +42204,7 @@ func NewValues_source_row_listContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source_row_list + p.RuleIndex = YQLParserRULE_values_source_row_list return p } @@ -42253,11 +42253,11 @@ func (s *Values_source_row_listContext) Values_source_row(i int) IValues_source_ } func (s *Values_source_row_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Values_source_row_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Values_source_row_listContext) GetRuleContext() antlr.RuleContext { @@ -42270,13 +42270,13 @@ func (s *Values_source_row_listContext) ToStringTree(ruleNames []string, recog a func (s *Values_source_row_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterValues_source_row_list(s) } } func (s *Values_source_row_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitValues_source_row_list(s) } } @@ -42284,9 +42284,9 @@ func (s *Values_source_row_listContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Values_source_row_list() (localctx IValues_source_row_listContext) { +func (p *YQLParser) Values_source_row_list() (localctx IValues_source_row_listContext) { localctx = NewValues_source_row_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 372, YQLv1Antlr4ParserRULE_values_source_row_list) + p.EnterRule(localctx, 372, YQLParserRULE_values_source_row_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -42302,10 +42302,10 @@ func (p *YQLv1Antlr4Parser) Values_source_row_list() (localctx IValues_source_ro _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2655) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42365,13 +42365,13 @@ type Values_source_rowContext struct { func NewEmptyValues_source_rowContext() *Values_source_rowContext { var p = new(Values_source_rowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source_row + p.RuleIndex = YQLParserRULE_values_source_row return p } func InitEmptyValues_source_rowContext(p *Values_source_rowContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source_row + p.RuleIndex = YQLParserRULE_values_source_row } func (*Values_source_rowContext) IsValues_source_rowContext() {} @@ -42382,7 +42382,7 @@ func NewValues_source_rowContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_values_source_row + p.RuleIndex = YQLParserRULE_values_source_row return p } @@ -42390,7 +42390,7 @@ func NewValues_source_rowContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Values_source_rowContext) GetParser() antlr.Parser { return s.parser } func (s *Values_source_rowContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Values_source_rowContext) Expr_list() IExpr_listContext { @@ -42410,7 +42410,7 @@ func (s *Values_source_rowContext) Expr_list() IExpr_listContext { } func (s *Values_source_rowContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Values_source_rowContext) GetRuleContext() antlr.RuleContext { @@ -42423,13 +42423,13 @@ func (s *Values_source_rowContext) ToStringTree(ruleNames []string, recog antlr. func (s *Values_source_rowContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterValues_source_row(s) } } func (s *Values_source_rowContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitValues_source_row(s) } } @@ -42437,13 +42437,13 @@ func (s *Values_source_rowContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Values_source_row() (localctx IValues_source_rowContext) { +func (p *YQLParser) Values_source_row() (localctx IValues_source_rowContext) { localctx = NewValues_source_rowContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 374, YQLv1Antlr4ParserRULE_values_source_row) + p.EnterRule(localctx, 374, YQLParserRULE_values_source_row) p.EnterOuterAlt(localctx, 1) { p.SetState(2662) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42455,7 +42455,7 @@ func (p *YQLv1Antlr4Parser) Values_source_row() (localctx IValues_source_rowCont } { p.SetState(2664) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42501,13 +42501,13 @@ type Simple_values_sourceContext struct { func NewEmptySimple_values_sourceContext() *Simple_values_sourceContext { var p = new(Simple_values_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_values_source + p.RuleIndex = YQLParserRULE_simple_values_source return p } func InitEmptySimple_values_sourceContext(p *Simple_values_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_values_source + p.RuleIndex = YQLParserRULE_simple_values_source } func (*Simple_values_sourceContext) IsSimple_values_sourceContext() {} @@ -42518,7 +42518,7 @@ func NewSimple_values_sourceContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_values_source + p.RuleIndex = YQLParserRULE_simple_values_source return p } @@ -42567,13 +42567,13 @@ func (s *Simple_values_sourceContext) ToStringTree(ruleNames []string, recog ant func (s *Simple_values_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSimple_values_source(s) } } func (s *Simple_values_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSimple_values_source(s) } } @@ -42581,9 +42581,9 @@ func (s *Simple_values_sourceContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Simple_values_source() (localctx ISimple_values_sourceContext) { +func (p *YQLParser) Simple_values_source() (localctx ISimple_values_sourceContext) { localctx = NewSimple_values_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 376, YQLv1Antlr4ParserRULE_simple_values_source) + p.EnterRule(localctx, 376, YQLParserRULE_simple_values_source) p.SetState(2668) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -42657,13 +42657,13 @@ type Create_external_data_source_stmtContext struct { func NewEmptyCreate_external_data_source_stmtContext() *Create_external_data_source_stmtContext { var p = new(Create_external_data_source_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_external_data_source_stmt + p.RuleIndex = YQLParserRULE_create_external_data_source_stmt return p } func InitEmptyCreate_external_data_source_stmtContext(p *Create_external_data_source_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_external_data_source_stmt + p.RuleIndex = YQLParserRULE_create_external_data_source_stmt } func (*Create_external_data_source_stmtContext) IsCreate_external_data_source_stmtContext() {} @@ -42674,7 +42674,7 @@ func NewCreate_external_data_source_stmtContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_external_data_source_stmt + p.RuleIndex = YQLParserRULE_create_external_data_source_stmt return p } @@ -42682,19 +42682,19 @@ func NewCreate_external_data_source_stmtContext(parser antlr.Parser, parent antl func (s *Create_external_data_source_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_external_data_source_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_external_data_source_stmtContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Create_external_data_source_stmtContext) DATA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATA, 0) + return s.GetToken(YQLParserDATA, 0) } func (s *Create_external_data_source_stmtContext) SOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSOURCE, 0) + return s.GetToken(YQLParserSOURCE, 0) } func (s *Create_external_data_source_stmtContext) Object_ref() IObject_refContext { @@ -42730,23 +42730,23 @@ func (s *Create_external_data_source_stmtContext) With_table_settings() IWith_ta } func (s *Create_external_data_source_stmtContext) OR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOR, 0) + return s.GetToken(YQLParserOR, 0) } func (s *Create_external_data_source_stmtContext) REPLACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLACE, 0) + return s.GetToken(YQLParserREPLACE, 0) } func (s *Create_external_data_source_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Create_external_data_source_stmtContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Create_external_data_source_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Create_external_data_source_stmtContext) GetRuleContext() antlr.RuleContext { @@ -42759,13 +42759,13 @@ func (s *Create_external_data_source_stmtContext) ToStringTree(ruleNames []strin func (s *Create_external_data_source_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_external_data_source_stmt(s) } } func (s *Create_external_data_source_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_external_data_source_stmt(s) } } @@ -42773,15 +42773,15 @@ func (s *Create_external_data_source_stmtContext) ExitRule(listener antlr.ParseT -func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate_external_data_source_stmtContext) { +func (p *YQLParser) Create_external_data_source_stmt() (localctx ICreate_external_data_source_stmtContext) { localctx = NewCreate_external_data_source_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 378, YQLv1Antlr4ParserRULE_create_external_data_source_stmt) + p.EnterRule(localctx, 378, YQLParserRULE_create_external_data_source_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2670) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42795,10 +42795,10 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserOR { + if _la == YQLParserOR { { p.SetState(2671) - p.Match(YQLv1Antlr4ParserOR) + p.Match(YQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42806,7 +42806,7 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate } { p.SetState(2672) - p.Match(YQLv1Antlr4ParserREPLACE) + p.Match(YQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42816,7 +42816,7 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate } { p.SetState(2675) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42824,7 +42824,7 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate } { p.SetState(2676) - p.Match(YQLv1Antlr4ParserDATA) + p.Match(YQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42832,7 +42832,7 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate } { p.SetState(2677) - p.Match(YQLv1Antlr4ParserSOURCE) + p.Match(YQLParserSOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42845,7 +42845,7 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 260, p.GetParserRuleContext()) == 1 { { p.SetState(2678) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42853,7 +42853,7 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate } { p.SetState(2679) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42861,7 +42861,7 @@ func (p *YQLv1Antlr4Parser) Create_external_data_source_stmt() (localctx ICreate } { p.SetState(2680) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42926,13 +42926,13 @@ type Alter_external_data_source_stmtContext struct { func NewEmptyAlter_external_data_source_stmtContext() *Alter_external_data_source_stmtContext { var p = new(Alter_external_data_source_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_data_source_stmt + p.RuleIndex = YQLParserRULE_alter_external_data_source_stmt return p } func InitEmptyAlter_external_data_source_stmtContext(p *Alter_external_data_source_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_data_source_stmt + p.RuleIndex = YQLParserRULE_alter_external_data_source_stmt } func (*Alter_external_data_source_stmtContext) IsAlter_external_data_source_stmtContext() {} @@ -42943,7 +42943,7 @@ func NewAlter_external_data_source_stmtContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_data_source_stmt + p.RuleIndex = YQLParserRULE_alter_external_data_source_stmt return p } @@ -42951,19 +42951,19 @@ func NewAlter_external_data_source_stmtContext(parser antlr.Parser, parent antlr func (s *Alter_external_data_source_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_external_data_source_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_external_data_source_stmtContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Alter_external_data_source_stmtContext) DATA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATA, 0) + return s.GetToken(YQLParserDATA, 0) } func (s *Alter_external_data_source_stmtContext) SOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSOURCE, 0) + return s.GetToken(YQLParserSOURCE, 0) } func (s *Alter_external_data_source_stmtContext) Object_ref() IObject_refContext { @@ -43024,11 +43024,11 @@ func (s *Alter_external_data_source_stmtContext) Alter_external_data_source_acti } func (s *Alter_external_data_source_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_external_data_source_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_external_data_source_stmtContext) GetRuleContext() antlr.RuleContext { @@ -43041,13 +43041,13 @@ func (s *Alter_external_data_source_stmtContext) ToStringTree(ruleNames []string func (s *Alter_external_data_source_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_external_data_source_stmt(s) } } func (s *Alter_external_data_source_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_external_data_source_stmt(s) } } @@ -43055,15 +43055,15 @@ func (s *Alter_external_data_source_stmtContext) ExitRule(listener antlr.ParseTr -func (p *YQLv1Antlr4Parser) Alter_external_data_source_stmt() (localctx IAlter_external_data_source_stmtContext) { +func (p *YQLParser) Alter_external_data_source_stmt() (localctx IAlter_external_data_source_stmtContext) { localctx = NewAlter_external_data_source_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 380, YQLv1Antlr4ParserRULE_alter_external_data_source_stmt) + p.EnterRule(localctx, 380, YQLParserRULE_alter_external_data_source_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2686) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43071,7 +43071,7 @@ func (p *YQLv1Antlr4Parser) Alter_external_data_source_stmt() (localctx IAlter_e } { p.SetState(2687) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43079,7 +43079,7 @@ func (p *YQLv1Antlr4Parser) Alter_external_data_source_stmt() (localctx IAlter_e } { p.SetState(2688) - p.Match(YQLv1Antlr4ParserDATA) + p.Match(YQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43087,7 +43087,7 @@ func (p *YQLv1Antlr4Parser) Alter_external_data_source_stmt() (localctx IAlter_e } { p.SetState(2689) - p.Match(YQLv1Antlr4ParserSOURCE) + p.Match(YQLParserSOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43109,10 +43109,10 @@ func (p *YQLv1Antlr4Parser) Alter_external_data_source_stmt() (localctx IAlter_e _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2692) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43172,13 +43172,13 @@ type Alter_external_data_source_actionContext struct { func NewEmptyAlter_external_data_source_actionContext() *Alter_external_data_source_actionContext { var p = new(Alter_external_data_source_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_data_source_action + p.RuleIndex = YQLParserRULE_alter_external_data_source_action return p } func InitEmptyAlter_external_data_source_actionContext(p *Alter_external_data_source_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_data_source_action + p.RuleIndex = YQLParserRULE_alter_external_data_source_action } func (*Alter_external_data_source_actionContext) IsAlter_external_data_source_actionContext() {} @@ -43189,7 +43189,7 @@ func NewAlter_external_data_source_actionContext(parser antlr.Parser, parent ant antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_data_source_action + p.RuleIndex = YQLParserRULE_alter_external_data_source_action return p } @@ -43254,13 +43254,13 @@ func (s *Alter_external_data_source_actionContext) ToStringTree(ruleNames []stri func (s *Alter_external_data_source_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_external_data_source_action(s) } } func (s *Alter_external_data_source_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_external_data_source_action(s) } } @@ -43268,9 +43268,9 @@ func (s *Alter_external_data_source_actionContext) ExitRule(listener antlr.Parse -func (p *YQLv1Antlr4Parser) Alter_external_data_source_action() (localctx IAlter_external_data_source_actionContext) { +func (p *YQLParser) Alter_external_data_source_action() (localctx IAlter_external_data_source_actionContext) { localctx = NewAlter_external_data_source_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 382, YQLv1Antlr4ParserRULE_alter_external_data_source_action) + p.EnterRule(localctx, 382, YQLParserRULE_alter_external_data_source_action) p.SetState(2702) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -43348,13 +43348,13 @@ type Drop_external_data_source_stmtContext struct { func NewEmptyDrop_external_data_source_stmtContext() *Drop_external_data_source_stmtContext { var p = new(Drop_external_data_source_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_external_data_source_stmt + p.RuleIndex = YQLParserRULE_drop_external_data_source_stmt return p } func InitEmptyDrop_external_data_source_stmtContext(p *Drop_external_data_source_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_external_data_source_stmt + p.RuleIndex = YQLParserRULE_drop_external_data_source_stmt } func (*Drop_external_data_source_stmtContext) IsDrop_external_data_source_stmtContext() {} @@ -43365,7 +43365,7 @@ func NewDrop_external_data_source_stmtContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_external_data_source_stmt + p.RuleIndex = YQLParserRULE_drop_external_data_source_stmt return p } @@ -43373,19 +43373,19 @@ func NewDrop_external_data_source_stmtContext(parser antlr.Parser, parent antlr. func (s *Drop_external_data_source_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_external_data_source_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_external_data_source_stmtContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Drop_external_data_source_stmtContext) DATA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATA, 0) + return s.GetToken(YQLParserDATA, 0) } func (s *Drop_external_data_source_stmtContext) SOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSOURCE, 0) + return s.GetToken(YQLParserSOURCE, 0) } func (s *Drop_external_data_source_stmtContext) Object_ref() IObject_refContext { @@ -43405,11 +43405,11 @@ func (s *Drop_external_data_source_stmtContext) Object_ref() IObject_refContext } func (s *Drop_external_data_source_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Drop_external_data_source_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Drop_external_data_source_stmtContext) GetRuleContext() antlr.RuleContext { @@ -43422,13 +43422,13 @@ func (s *Drop_external_data_source_stmtContext) ToStringTree(ruleNames []string, func (s *Drop_external_data_source_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_external_data_source_stmt(s) } } func (s *Drop_external_data_source_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_external_data_source_stmt(s) } } @@ -43436,13 +43436,13 @@ func (s *Drop_external_data_source_stmtContext) ExitRule(listener antlr.ParseTre -func (p *YQLv1Antlr4Parser) Drop_external_data_source_stmt() (localctx IDrop_external_data_source_stmtContext) { +func (p *YQLParser) Drop_external_data_source_stmt() (localctx IDrop_external_data_source_stmtContext) { localctx = NewDrop_external_data_source_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 384, YQLv1Antlr4ParserRULE_drop_external_data_source_stmt) + p.EnterRule(localctx, 384, YQLParserRULE_drop_external_data_source_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2704) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43450,7 +43450,7 @@ func (p *YQLv1Antlr4Parser) Drop_external_data_source_stmt() (localctx IDrop_ext } { p.SetState(2705) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43458,7 +43458,7 @@ func (p *YQLv1Antlr4Parser) Drop_external_data_source_stmt() (localctx IDrop_ext } { p.SetState(2706) - p.Match(YQLv1Antlr4ParserDATA) + p.Match(YQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43466,7 +43466,7 @@ func (p *YQLv1Antlr4Parser) Drop_external_data_source_stmt() (localctx IDrop_ext } { p.SetState(2707) - p.Match(YQLv1Antlr4ParserSOURCE) + p.Match(YQLParserSOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43479,7 +43479,7 @@ func (p *YQLv1Antlr4Parser) Drop_external_data_source_stmt() (localctx IDrop_ext if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) == 1 { { p.SetState(2708) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43487,7 +43487,7 @@ func (p *YQLv1Antlr4Parser) Drop_external_data_source_stmt() (localctx IDrop_ext } { p.SetState(2709) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43548,13 +43548,13 @@ type Create_view_stmtContext struct { func NewEmptyCreate_view_stmtContext() *Create_view_stmtContext { var p = new(Create_view_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_view_stmt + p.RuleIndex = YQLParserRULE_create_view_stmt return p } func InitEmptyCreate_view_stmtContext(p *Create_view_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_view_stmt + p.RuleIndex = YQLParserRULE_create_view_stmt } func (*Create_view_stmtContext) IsCreate_view_stmtContext() {} @@ -43565,7 +43565,7 @@ func NewCreate_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_view_stmt + p.RuleIndex = YQLParserRULE_create_view_stmt return p } @@ -43573,11 +43573,11 @@ func NewCreate_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Create_view_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_view_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_view_stmtContext) VIEW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIEW, 0) + return s.GetToken(YQLParserVIEW, 0) } func (s *Create_view_stmtContext) Object_ref() IObject_refContext { @@ -43597,7 +43597,7 @@ func (s *Create_view_stmtContext) Object_ref() IObject_refContext { } func (s *Create_view_stmtContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Create_view_stmtContext) Select_stmt() ISelect_stmtContext { @@ -43617,15 +43617,15 @@ func (s *Create_view_stmtContext) Select_stmt() ISelect_stmtContext { } func (s *Create_view_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Create_view_stmtContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Create_view_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Create_view_stmtContext) Create_object_features() ICreate_object_featuresContext { @@ -43654,13 +43654,13 @@ func (s *Create_view_stmtContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Create_view_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_view_stmt(s) } } func (s *Create_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_view_stmt(s) } } @@ -43668,15 +43668,15 @@ func (s *Create_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_view_stmt() (localctx ICreate_view_stmtContext) { +func (p *YQLParser) Create_view_stmt() (localctx ICreate_view_stmtContext) { localctx = NewCreate_view_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 386, YQLv1Antlr4ParserRULE_create_view_stmt) + p.EnterRule(localctx, 386, YQLParserRULE_create_view_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2714) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43684,7 +43684,7 @@ func (p *YQLv1Antlr4Parser) Create_view_stmt() (localctx ICreate_view_stmtContex } { p.SetState(2715) - p.Match(YQLv1Antlr4ParserVIEW) + p.Match(YQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43697,7 +43697,7 @@ func (p *YQLv1Antlr4Parser) Create_view_stmt() (localctx ICreate_view_stmtContex if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 264, p.GetParserRuleContext()) == 1 { { p.SetState(2716) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43705,7 +43705,7 @@ func (p *YQLv1Antlr4Parser) Create_view_stmt() (localctx ICreate_view_stmtContex } { p.SetState(2717) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43713,7 +43713,7 @@ func (p *YQLv1Antlr4Parser) Create_view_stmt() (localctx ICreate_view_stmtContex } { p.SetState(2718) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43735,7 +43735,7 @@ func (p *YQLv1Antlr4Parser) Create_view_stmt() (localctx ICreate_view_stmtContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(2722) p.Create_object_features() @@ -43744,7 +43744,7 @@ func (p *YQLv1Antlr4Parser) Create_view_stmt() (localctx ICreate_view_stmtContex } { p.SetState(2725) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43797,13 +43797,13 @@ type Drop_view_stmtContext struct { func NewEmptyDrop_view_stmtContext() *Drop_view_stmtContext { var p = new(Drop_view_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_view_stmt + p.RuleIndex = YQLParserRULE_drop_view_stmt return p } func InitEmptyDrop_view_stmtContext(p *Drop_view_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_view_stmt + p.RuleIndex = YQLParserRULE_drop_view_stmt } func (*Drop_view_stmtContext) IsDrop_view_stmtContext() {} @@ -43814,7 +43814,7 @@ func NewDrop_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_view_stmt + p.RuleIndex = YQLParserRULE_drop_view_stmt return p } @@ -43822,11 +43822,11 @@ func NewDrop_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Drop_view_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_view_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_view_stmtContext) VIEW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIEW, 0) + return s.GetToken(YQLParserVIEW, 0) } func (s *Drop_view_stmtContext) Object_ref() IObject_refContext { @@ -43846,11 +43846,11 @@ func (s *Drop_view_stmtContext) Object_ref() IObject_refContext { } func (s *Drop_view_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Drop_view_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Drop_view_stmtContext) GetRuleContext() antlr.RuleContext { @@ -43863,13 +43863,13 @@ func (s *Drop_view_stmtContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Drop_view_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_view_stmt(s) } } func (s *Drop_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_view_stmt(s) } } @@ -43877,13 +43877,13 @@ func (s *Drop_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Drop_view_stmt() (localctx IDrop_view_stmtContext) { +func (p *YQLParser) Drop_view_stmt() (localctx IDrop_view_stmtContext) { localctx = NewDrop_view_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 388, YQLv1Antlr4ParserRULE_drop_view_stmt) + p.EnterRule(localctx, 388, YQLParserRULE_drop_view_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2728) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43891,7 +43891,7 @@ func (p *YQLv1Antlr4Parser) Drop_view_stmt() (localctx IDrop_view_stmtContext) { } { p.SetState(2729) - p.Match(YQLv1Antlr4ParserVIEW) + p.Match(YQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43904,7 +43904,7 @@ func (p *YQLv1Antlr4Parser) Drop_view_stmt() (localctx IDrop_view_stmtContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 266, p.GetParserRuleContext()) == 1 { { p.SetState(2730) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43912,7 +43912,7 @@ func (p *YQLv1Antlr4Parser) Drop_view_stmt() (localctx IDrop_view_stmtContext) { } { p.SetState(2731) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43972,13 +43972,13 @@ type Upsert_object_stmtContext struct { func NewEmptyUpsert_object_stmtContext() *Upsert_object_stmtContext { var p = new(Upsert_object_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_upsert_object_stmt + p.RuleIndex = YQLParserRULE_upsert_object_stmt return p } func InitEmptyUpsert_object_stmtContext(p *Upsert_object_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_upsert_object_stmt + p.RuleIndex = YQLParserRULE_upsert_object_stmt } func (*Upsert_object_stmtContext) IsUpsert_object_stmtContext() {} @@ -43989,7 +43989,7 @@ func NewUpsert_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_upsert_object_stmt + p.RuleIndex = YQLParserRULE_upsert_object_stmt return p } @@ -43997,11 +43997,11 @@ func NewUpsert_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Upsert_object_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Upsert_object_stmtContext) UPSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPSERT, 0) + return s.GetToken(YQLParserUPSERT, 0) } func (s *Upsert_object_stmtContext) OBJECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOBJECT, 0) + return s.GetToken(YQLParserOBJECT, 0) } func (s *Upsert_object_stmtContext) Object_ref() IObject_refContext { @@ -44021,11 +44021,11 @@ func (s *Upsert_object_stmtContext) Object_ref() IObject_refContext { } func (s *Upsert_object_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Upsert_object_stmtContext) TYPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTYPE, 0) + return s.GetToken(YQLParserTYPE, 0) } func (s *Upsert_object_stmtContext) Object_type_ref() IObject_type_refContext { @@ -44045,7 +44045,7 @@ func (s *Upsert_object_stmtContext) Object_type_ref() IObject_type_refContext { } func (s *Upsert_object_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Upsert_object_stmtContext) Create_object_features() ICreate_object_featuresContext { @@ -44074,13 +44074,13 @@ func (s *Upsert_object_stmtContext) ToStringTree(ruleNames []string, recog antlr func (s *Upsert_object_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUpsert_object_stmt(s) } } func (s *Upsert_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUpsert_object_stmt(s) } } @@ -44088,15 +44088,15 @@ func (s *Upsert_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Upsert_object_stmt() (localctx IUpsert_object_stmtContext) { +func (p *YQLParser) Upsert_object_stmt() (localctx IUpsert_object_stmtContext) { localctx = NewUpsert_object_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 390, YQLv1Antlr4ParserRULE_upsert_object_stmt) + p.EnterRule(localctx, 390, YQLParserRULE_upsert_object_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2736) - p.Match(YQLv1Antlr4ParserUPSERT) + p.Match(YQLParserUPSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44104,7 +44104,7 @@ func (p *YQLv1Antlr4Parser) Upsert_object_stmt() (localctx IUpsert_object_stmtCo } { p.SetState(2737) - p.Match(YQLv1Antlr4ParserOBJECT) + p.Match(YQLParserOBJECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44116,7 +44116,7 @@ func (p *YQLv1Antlr4Parser) Upsert_object_stmt() (localctx IUpsert_object_stmtCo } { p.SetState(2739) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44124,7 +44124,7 @@ func (p *YQLv1Antlr4Parser) Upsert_object_stmt() (localctx IUpsert_object_stmtCo } { p.SetState(2740) - p.Match(YQLv1Antlr4ParserTYPE) + p.Match(YQLParserTYPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44136,7 +44136,7 @@ func (p *YQLv1Antlr4Parser) Upsert_object_stmt() (localctx IUpsert_object_stmtCo } { p.SetState(2742) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44150,7 +44150,7 @@ func (p *YQLv1Antlr4Parser) Upsert_object_stmt() (localctx IUpsert_object_stmtCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(2743) p.Create_object_features() @@ -44206,13 +44206,13 @@ type Create_object_stmtContext struct { func NewEmptyCreate_object_stmtContext() *Create_object_stmtContext { var p = new(Create_object_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_object_stmt + p.RuleIndex = YQLParserRULE_create_object_stmt return p } func InitEmptyCreate_object_stmtContext(p *Create_object_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_object_stmt + p.RuleIndex = YQLParserRULE_create_object_stmt } func (*Create_object_stmtContext) IsCreate_object_stmtContext() {} @@ -44223,7 +44223,7 @@ func NewCreate_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_object_stmt + p.RuleIndex = YQLParserRULE_create_object_stmt return p } @@ -44231,11 +44231,11 @@ func NewCreate_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Create_object_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_object_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_object_stmtContext) OBJECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOBJECT, 0) + return s.GetToken(YQLParserOBJECT, 0) } func (s *Create_object_stmtContext) Object_ref() IObject_refContext { @@ -44255,11 +44255,11 @@ func (s *Create_object_stmtContext) Object_ref() IObject_refContext { } func (s *Create_object_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Create_object_stmtContext) TYPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTYPE, 0) + return s.GetToken(YQLParserTYPE, 0) } func (s *Create_object_stmtContext) Object_type_ref() IObject_type_refContext { @@ -44279,19 +44279,19 @@ func (s *Create_object_stmtContext) Object_type_ref() IObject_type_refContext { } func (s *Create_object_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Create_object_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Create_object_stmtContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Create_object_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Create_object_stmtContext) Create_object_features() ICreate_object_featuresContext { @@ -44320,13 +44320,13 @@ func (s *Create_object_stmtContext) ToStringTree(ruleNames []string, recog antlr func (s *Create_object_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_object_stmt(s) } } func (s *Create_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_object_stmt(s) } } @@ -44334,15 +44334,15 @@ func (s *Create_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtContext) { +func (p *YQLParser) Create_object_stmt() (localctx ICreate_object_stmtContext) { localctx = NewCreate_object_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 392, YQLv1Antlr4ParserRULE_create_object_stmt) + p.EnterRule(localctx, 392, YQLParserRULE_create_object_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2746) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44350,7 +44350,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo } { p.SetState(2747) - p.Match(YQLv1Antlr4ParserOBJECT) + p.Match(YQLParserOBJECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44363,7 +44363,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 268, p.GetParserRuleContext()) == 1 { { p.SetState(2748) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44371,7 +44371,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo } { p.SetState(2749) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44379,7 +44379,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo } { p.SetState(2750) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44395,7 +44395,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo } { p.SetState(2754) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44403,7 +44403,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo } { p.SetState(2755) - p.Match(YQLv1Antlr4ParserTYPE) + p.Match(YQLParserTYPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44415,7 +44415,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo } { p.SetState(2757) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44429,7 +44429,7 @@ func (p *YQLv1Antlr4Parser) Create_object_stmt() (localctx ICreate_object_stmtCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(2758) p.Create_object_features() @@ -44476,13 +44476,13 @@ type Create_object_featuresContext struct { func NewEmptyCreate_object_featuresContext() *Create_object_featuresContext { var p = new(Create_object_featuresContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_object_features + p.RuleIndex = YQLParserRULE_create_object_features return p } func InitEmptyCreate_object_featuresContext(p *Create_object_featuresContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_object_features + p.RuleIndex = YQLParserRULE_create_object_features } func (*Create_object_featuresContext) IsCreate_object_featuresContext() {} @@ -44493,7 +44493,7 @@ func NewCreate_object_featuresContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_object_features + p.RuleIndex = YQLParserRULE_create_object_features return p } @@ -44501,7 +44501,7 @@ func NewCreate_object_featuresContext(parser antlr.Parser, parent antlr.ParserRu func (s *Create_object_featuresContext) GetParser() antlr.Parser { return s.parser } func (s *Create_object_featuresContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Create_object_featuresContext) Object_features() IObject_featuresContext { @@ -44530,13 +44530,13 @@ func (s *Create_object_featuresContext) ToStringTree(ruleNames []string, recog a func (s *Create_object_featuresContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_object_features(s) } } func (s *Create_object_featuresContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_object_features(s) } } @@ -44544,13 +44544,13 @@ func (s *Create_object_featuresContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Create_object_features() (localctx ICreate_object_featuresContext) { +func (p *YQLParser) Create_object_features() (localctx ICreate_object_featuresContext) { localctx = NewCreate_object_featuresContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 394, YQLv1Antlr4ParserRULE_create_object_features) + p.EnterRule(localctx, 394, YQLParserRULE_create_object_features) p.EnterOuterAlt(localctx, 1) { p.SetState(2761) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44606,13 +44606,13 @@ type Alter_object_stmtContext struct { func NewEmptyAlter_object_stmtContext() *Alter_object_stmtContext { var p = new(Alter_object_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_object_stmt + p.RuleIndex = YQLParserRULE_alter_object_stmt return p } func InitEmptyAlter_object_stmtContext(p *Alter_object_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_object_stmt + p.RuleIndex = YQLParserRULE_alter_object_stmt } func (*Alter_object_stmtContext) IsAlter_object_stmtContext() {} @@ -44623,7 +44623,7 @@ func NewAlter_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_object_stmt + p.RuleIndex = YQLParserRULE_alter_object_stmt return p } @@ -44631,11 +44631,11 @@ func NewAlter_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Alter_object_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_object_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_object_stmtContext) OBJECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOBJECT, 0) + return s.GetToken(YQLParserOBJECT, 0) } func (s *Alter_object_stmtContext) Object_ref() IObject_refContext { @@ -44655,11 +44655,11 @@ func (s *Alter_object_stmtContext) Object_ref() IObject_refContext { } func (s *Alter_object_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Alter_object_stmtContext) TYPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTYPE, 0) + return s.GetToken(YQLParserTYPE, 0) } func (s *Alter_object_stmtContext) Object_type_ref() IObject_type_refContext { @@ -44679,7 +44679,7 @@ func (s *Alter_object_stmtContext) Object_type_ref() IObject_type_refContext { } func (s *Alter_object_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Alter_object_stmtContext) Alter_object_features() IAlter_object_featuresContext { @@ -44708,13 +44708,13 @@ func (s *Alter_object_stmtContext) ToStringTree(ruleNames []string, recog antlr. func (s *Alter_object_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_object_stmt(s) } } func (s *Alter_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_object_stmt(s) } } @@ -44722,13 +44722,13 @@ func (s *Alter_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Alter_object_stmt() (localctx IAlter_object_stmtContext) { +func (p *YQLParser) Alter_object_stmt() (localctx IAlter_object_stmtContext) { localctx = NewAlter_object_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 396, YQLv1Antlr4ParserRULE_alter_object_stmt) + p.EnterRule(localctx, 396, YQLParserRULE_alter_object_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2764) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44736,7 +44736,7 @@ func (p *YQLv1Antlr4Parser) Alter_object_stmt() (localctx IAlter_object_stmtCont } { p.SetState(2765) - p.Match(YQLv1Antlr4ParserOBJECT) + p.Match(YQLParserOBJECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44748,7 +44748,7 @@ func (p *YQLv1Antlr4Parser) Alter_object_stmt() (localctx IAlter_object_stmtCont } { p.SetState(2767) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44756,7 +44756,7 @@ func (p *YQLv1Antlr4Parser) Alter_object_stmt() (localctx IAlter_object_stmtCont } { p.SetState(2768) - p.Match(YQLv1Antlr4ParserTYPE) + p.Match(YQLParserTYPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44768,7 +44768,7 @@ func (p *YQLv1Antlr4Parser) Alter_object_stmt() (localctx IAlter_object_stmtCont } { p.SetState(2770) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44818,13 +44818,13 @@ type Alter_object_featuresContext struct { func NewEmptyAlter_object_featuresContext() *Alter_object_featuresContext { var p = new(Alter_object_featuresContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_object_features + p.RuleIndex = YQLParserRULE_alter_object_features return p } func InitEmptyAlter_object_featuresContext(p *Alter_object_featuresContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_object_features + p.RuleIndex = YQLParserRULE_alter_object_features } func (*Alter_object_featuresContext) IsAlter_object_featuresContext() {} @@ -44835,7 +44835,7 @@ func NewAlter_object_featuresContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_object_features + p.RuleIndex = YQLParserRULE_alter_object_features return p } @@ -44843,7 +44843,7 @@ func NewAlter_object_featuresContext(parser antlr.Parser, parent antlr.ParserRul func (s *Alter_object_featuresContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_object_featuresContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Alter_object_featuresContext) Object_features() IObject_featuresContext { @@ -44872,13 +44872,13 @@ func (s *Alter_object_featuresContext) ToStringTree(ruleNames []string, recog an func (s *Alter_object_featuresContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_object_features(s) } } func (s *Alter_object_featuresContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_object_features(s) } } @@ -44886,13 +44886,13 @@ func (s *Alter_object_featuresContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Alter_object_features() (localctx IAlter_object_featuresContext) { +func (p *YQLParser) Alter_object_features() (localctx IAlter_object_featuresContext) { localctx = NewAlter_object_featuresContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 398, YQLv1Antlr4ParserRULE_alter_object_features) + p.EnterRule(localctx, 398, YQLParserRULE_alter_object_features) p.EnterOuterAlt(localctx, 1) { p.SetState(2773) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44950,13 +44950,13 @@ type Drop_object_stmtContext struct { func NewEmptyDrop_object_stmtContext() *Drop_object_stmtContext { var p = new(Drop_object_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_object_stmt + p.RuleIndex = YQLParserRULE_drop_object_stmt return p } func InitEmptyDrop_object_stmtContext(p *Drop_object_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_object_stmt + p.RuleIndex = YQLParserRULE_drop_object_stmt } func (*Drop_object_stmtContext) IsDrop_object_stmtContext() {} @@ -44967,7 +44967,7 @@ func NewDrop_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_object_stmt + p.RuleIndex = YQLParserRULE_drop_object_stmt return p } @@ -44975,11 +44975,11 @@ func NewDrop_object_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Drop_object_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_object_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_object_stmtContext) OBJECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOBJECT, 0) + return s.GetToken(YQLParserOBJECT, 0) } func (s *Drop_object_stmtContext) Object_ref() IObject_refContext { @@ -44999,11 +44999,11 @@ func (s *Drop_object_stmtContext) Object_ref() IObject_refContext { } func (s *Drop_object_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Drop_object_stmtContext) TYPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTYPE, 0) + return s.GetToken(YQLParserTYPE, 0) } func (s *Drop_object_stmtContext) Object_type_ref() IObject_type_refContext { @@ -45023,15 +45023,15 @@ func (s *Drop_object_stmtContext) Object_type_ref() IObject_type_refContext { } func (s *Drop_object_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Drop_object_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Drop_object_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Drop_object_stmtContext) Drop_object_features() IDrop_object_featuresContext { @@ -45060,13 +45060,13 @@ func (s *Drop_object_stmtContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Drop_object_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_object_stmt(s) } } func (s *Drop_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_object_stmt(s) } } @@ -45074,15 +45074,15 @@ func (s *Drop_object_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContext) { +func (p *YQLParser) Drop_object_stmt() (localctx IDrop_object_stmtContext) { localctx = NewDrop_object_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 400, YQLv1Antlr4ParserRULE_drop_object_stmt) + p.EnterRule(localctx, 400, YQLParserRULE_drop_object_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2776) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45090,7 +45090,7 @@ func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContex } { p.SetState(2777) - p.Match(YQLv1Antlr4ParserOBJECT) + p.Match(YQLParserOBJECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45103,7 +45103,7 @@ func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContex if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 270, p.GetParserRuleContext()) == 1 { { p.SetState(2778) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45111,7 +45111,7 @@ func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContex } { p.SetState(2779) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45127,7 +45127,7 @@ func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContex } { p.SetState(2783) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45135,7 +45135,7 @@ func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContex } { p.SetState(2784) - p.Match(YQLv1Antlr4ParserTYPE) + p.Match(YQLParserTYPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45147,7 +45147,7 @@ func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContex } { p.SetState(2786) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45161,7 +45161,7 @@ func (p *YQLv1Antlr4Parser) Drop_object_stmt() (localctx IDrop_object_stmtContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(2787) p.Drop_object_features() @@ -45208,13 +45208,13 @@ type Drop_object_featuresContext struct { func NewEmptyDrop_object_featuresContext() *Drop_object_featuresContext { var p = new(Drop_object_featuresContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_object_features + p.RuleIndex = YQLParserRULE_drop_object_features return p } func InitEmptyDrop_object_featuresContext(p *Drop_object_featuresContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_object_features + p.RuleIndex = YQLParserRULE_drop_object_features } func (*Drop_object_featuresContext) IsDrop_object_featuresContext() {} @@ -45225,7 +45225,7 @@ func NewDrop_object_featuresContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_object_features + p.RuleIndex = YQLParserRULE_drop_object_features return p } @@ -45233,7 +45233,7 @@ func NewDrop_object_featuresContext(parser antlr.Parser, parent antlr.ParserRule func (s *Drop_object_featuresContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_object_featuresContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Drop_object_featuresContext) Object_features() IObject_featuresContext { @@ -45262,13 +45262,13 @@ func (s *Drop_object_featuresContext) ToStringTree(ruleNames []string, recog ant func (s *Drop_object_featuresContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_object_features(s) } } func (s *Drop_object_featuresContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_object_features(s) } } @@ -45276,13 +45276,13 @@ func (s *Drop_object_featuresContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Drop_object_features() (localctx IDrop_object_featuresContext) { +func (p *YQLParser) Drop_object_features() (localctx IDrop_object_featuresContext) { localctx = NewDrop_object_featuresContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 402, YQLv1Antlr4ParserRULE_drop_object_features) + p.EnterRule(localctx, 402, YQLParserRULE_drop_object_features) p.EnterOuterAlt(localctx, 1) { p.SetState(2790) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45334,13 +45334,13 @@ type Object_feature_valueContext struct { func NewEmptyObject_feature_valueContext() *Object_feature_valueContext { var p = new(Object_feature_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_value + p.RuleIndex = YQLParserRULE_object_feature_value return p } func InitEmptyObject_feature_valueContext(p *Object_feature_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_value + p.RuleIndex = YQLParserRULE_object_feature_value } func (*Object_feature_valueContext) IsObject_feature_valueContext() {} @@ -45351,7 +45351,7 @@ func NewObject_feature_valueContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_value + p.RuleIndex = YQLParserRULE_object_feature_value return p } @@ -45391,7 +45391,7 @@ func (s *Object_feature_valueContext) Bind_parameter() IBind_parameterContext { } func (s *Object_feature_valueContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Object_feature_valueContext) Bool_value() IBool_valueContext { @@ -45420,13 +45420,13 @@ func (s *Object_feature_valueContext) ToStringTree(ruleNames []string, recog ant func (s *Object_feature_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterObject_feature_value(s) } } func (s *Object_feature_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitObject_feature_value(s) } } @@ -45434,9 +45434,9 @@ func (s *Object_feature_valueContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Object_feature_value() (localctx IObject_feature_valueContext) { +func (p *YQLParser) Object_feature_value() (localctx IObject_feature_valueContext) { localctx = NewObject_feature_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 404, YQLv1Antlr4ParserRULE_object_feature_value) + p.EnterRule(localctx, 404, YQLParserRULE_object_feature_value) p.SetState(2797) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -45444,7 +45444,7 @@ func (p *YQLv1Antlr4Parser) Object_feature_value() (localctx IObject_feature_val } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(2793) @@ -45452,7 +45452,7 @@ func (p *YQLv1Antlr4Parser) Object_feature_value() (localctx IObject_feature_val } - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 2) { p.SetState(2794) @@ -45460,11 +45460,11 @@ func (p *YQLv1Antlr4Parser) Object_feature_value() (localctx IObject_feature_val } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 3) { p.SetState(2795) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45472,7 +45472,7 @@ func (p *YQLv1Antlr4Parser) Object_feature_value() (localctx IObject_feature_val } - case YQLv1Antlr4ParserFALSE, YQLv1Antlr4ParserTRUE: + case YQLParserFALSE, YQLParserTRUE: p.EnterOuterAlt(localctx, 4) { p.SetState(2796) @@ -45525,13 +45525,13 @@ type Object_feature_kvContext struct { func NewEmptyObject_feature_kvContext() *Object_feature_kvContext { var p = new(Object_feature_kvContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_kv + p.RuleIndex = YQLParserRULE_object_feature_kv return p } func InitEmptyObject_feature_kvContext(p *Object_feature_kvContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_kv + p.RuleIndex = YQLParserRULE_object_feature_kv } func (*Object_feature_kvContext) IsObject_feature_kvContext() {} @@ -45542,7 +45542,7 @@ func NewObject_feature_kvContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_kv + p.RuleIndex = YQLParserRULE_object_feature_kv return p } @@ -45566,7 +45566,7 @@ func (s *Object_feature_kvContext) An_id_or_type() IAn_id_or_typeContext { } func (s *Object_feature_kvContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Object_feature_kvContext) Object_feature_value() IObject_feature_valueContext { @@ -45595,13 +45595,13 @@ func (s *Object_feature_kvContext) ToStringTree(ruleNames []string, recog antlr. func (s *Object_feature_kvContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterObject_feature_kv(s) } } func (s *Object_feature_kvContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitObject_feature_kv(s) } } @@ -45609,9 +45609,9 @@ func (s *Object_feature_kvContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Object_feature_kv() (localctx IObject_feature_kvContext) { +func (p *YQLParser) Object_feature_kv() (localctx IObject_feature_kvContext) { localctx = NewObject_feature_kvContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 406, YQLv1Antlr4ParserRULE_object_feature_kv) + p.EnterRule(localctx, 406, YQLParserRULE_object_feature_kv) p.EnterOuterAlt(localctx, 1) { p.SetState(2799) @@ -45619,7 +45619,7 @@ func (p *YQLv1Antlr4Parser) Object_feature_kv() (localctx IObject_feature_kvCont } { p.SetState(2800) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45668,13 +45668,13 @@ type Object_feature_flagContext struct { func NewEmptyObject_feature_flagContext() *Object_feature_flagContext { var p = new(Object_feature_flagContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_flag + p.RuleIndex = YQLParserRULE_object_feature_flag return p } func InitEmptyObject_feature_flagContext(p *Object_feature_flagContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_flag + p.RuleIndex = YQLParserRULE_object_feature_flag } func (*Object_feature_flagContext) IsObject_feature_flagContext() {} @@ -45685,7 +45685,7 @@ func NewObject_feature_flagContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature_flag + p.RuleIndex = YQLParserRULE_object_feature_flag return p } @@ -45718,13 +45718,13 @@ func (s *Object_feature_flagContext) ToStringTree(ruleNames []string, recog antl func (s *Object_feature_flagContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterObject_feature_flag(s) } } func (s *Object_feature_flagContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitObject_feature_flag(s) } } @@ -45732,9 +45732,9 @@ func (s *Object_feature_flagContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Object_feature_flag() (localctx IObject_feature_flagContext) { +func (p *YQLParser) Object_feature_flag() (localctx IObject_feature_flagContext) { localctx = NewObject_feature_flagContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 408, YQLv1Antlr4ParserRULE_object_feature_flag) + p.EnterRule(localctx, 408, YQLParserRULE_object_feature_flag) p.EnterOuterAlt(localctx, 1) { p.SetState(2803) @@ -45780,13 +45780,13 @@ type Object_featureContext struct { func NewEmptyObject_featureContext() *Object_featureContext { var p = new(Object_featureContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature + p.RuleIndex = YQLParserRULE_object_feature return p } func InitEmptyObject_featureContext(p *Object_featureContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature + p.RuleIndex = YQLParserRULE_object_feature } func (*Object_featureContext) IsObject_featureContext() {} @@ -45797,7 +45797,7 @@ func NewObject_featureContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_object_feature + p.RuleIndex = YQLParserRULE_object_feature return p } @@ -45846,13 +45846,13 @@ func (s *Object_featureContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Object_featureContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterObject_feature(s) } } func (s *Object_featureContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitObject_feature(s) } } @@ -45860,9 +45860,9 @@ func (s *Object_featureContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Object_feature() (localctx IObject_featureContext) { +func (p *YQLParser) Object_feature() (localctx IObject_featureContext) { localctx = NewObject_featureContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 410, YQLv1Antlr4ParserRULE_object_feature) + p.EnterRule(localctx, 410, YQLParserRULE_object_feature) p.SetState(2807) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -45931,13 +45931,13 @@ type Object_featuresContext struct { func NewEmptyObject_featuresContext() *Object_featuresContext { var p = new(Object_featuresContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_features + p.RuleIndex = YQLParserRULE_object_features return p } func InitEmptyObject_featuresContext(p *Object_featuresContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_features + p.RuleIndex = YQLParserRULE_object_features } func (*Object_featuresContext) IsObject_featuresContext() {} @@ -45948,7 +45948,7 @@ func NewObject_featuresContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_object_features + p.RuleIndex = YQLParserRULE_object_features return p } @@ -45997,19 +45997,19 @@ func (s *Object_featuresContext) Object_feature(i int) IObject_featureContext { } func (s *Object_featuresContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Object_featuresContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Object_featuresContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Object_featuresContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Object_featuresContext) GetRuleContext() antlr.RuleContext { @@ -46022,13 +46022,13 @@ func (s *Object_featuresContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Object_featuresContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterObject_features(s) } } func (s *Object_featuresContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitObject_features(s) } } @@ -46036,9 +46036,9 @@ func (s *Object_featuresContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Object_features() (localctx IObject_featuresContext) { +func (p *YQLParser) Object_features() (localctx IObject_featuresContext) { localctx = NewObject_featuresContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 412, YQLv1Antlr4ParserRULE_object_features) + p.EnterRule(localctx, 412, YQLParserRULE_object_features) var _la int p.SetState(2821) @@ -46048,7 +46048,7 @@ func (p *YQLv1Antlr4Parser) Object_features() (localctx IObject_featuresContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(2809) @@ -46056,11 +46056,11 @@ func (p *YQLv1Antlr4Parser) Object_features() (localctx IObject_featuresContext) } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(2810) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46078,10 +46078,10 @@ func (p *YQLv1Antlr4Parser) Object_features() (localctx IObject_featuresContext) _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2812) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46102,7 +46102,7 @@ func (p *YQLv1Antlr4Parser) Object_features() (localctx IObject_featuresContext) } { p.SetState(2819) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46153,13 +46153,13 @@ type Object_type_refContext struct { func NewEmptyObject_type_refContext() *Object_type_refContext { var p = new(Object_type_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_type_ref + p.RuleIndex = YQLParserRULE_object_type_ref return p } func InitEmptyObject_type_refContext(p *Object_type_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_type_ref + p.RuleIndex = YQLParserRULE_object_type_ref } func (*Object_type_refContext) IsObject_type_refContext() {} @@ -46170,7 +46170,7 @@ func NewObject_type_refContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_object_type_ref + p.RuleIndex = YQLParserRULE_object_type_ref return p } @@ -46203,13 +46203,13 @@ func (s *Object_type_refContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Object_type_refContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterObject_type_ref(s) } } func (s *Object_type_refContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitObject_type_ref(s) } } @@ -46217,9 +46217,9 @@ func (s *Object_type_refContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Object_type_ref() (localctx IObject_type_refContext) { +func (p *YQLParser) Object_type_ref() (localctx IObject_type_refContext) { localctx = NewObject_type_refContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 414, YQLv1Antlr4ParserRULE_object_type_ref) + p.EnterRule(localctx, 414, YQLParserRULE_object_type_ref) p.EnterOuterAlt(localctx, 1) { p.SetState(2823) @@ -46286,13 +46286,13 @@ type Create_table_stmtContext struct { func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext { var p = new(Create_table_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_table_stmt + p.RuleIndex = YQLParserRULE_create_table_stmt return p } func InitEmptyCreate_table_stmtContext(p *Create_table_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_table_stmt + p.RuleIndex = YQLParserRULE_create_table_stmt } func (*Create_table_stmtContext) IsCreate_table_stmtContext() {} @@ -46303,7 +46303,7 @@ func NewCreate_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_table_stmt + p.RuleIndex = YQLParserRULE_create_table_stmt return p } @@ -46311,7 +46311,7 @@ func NewCreate_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Create_table_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_table_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_table_stmtContext) Simple_table_ref() ISimple_table_refContext { @@ -46331,7 +46331,7 @@ func (s *Create_table_stmtContext) Simple_table_ref() ISimple_table_refContext { } func (s *Create_table_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Create_table_stmtContext) AllCreate_table_entry() []ICreate_table_entryContext { @@ -46376,55 +46376,55 @@ func (s *Create_table_stmtContext) Create_table_entry(i int) ICreate_table_entry } func (s *Create_table_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Create_table_stmtContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Create_table_stmtContext) TABLESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESTORE, 0) + return s.GetToken(YQLParserTABLESTORE, 0) } func (s *Create_table_stmtContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Create_table_stmtContext) TEMP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTEMP, 0) + return s.GetToken(YQLParserTEMP, 0) } func (s *Create_table_stmtContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTEMPORARY, 0) + return s.GetToken(YQLParserTEMPORARY, 0) } func (s *Create_table_stmtContext) OR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOR, 0) + return s.GetToken(YQLParserOR, 0) } func (s *Create_table_stmtContext) REPLACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLACE, 0) + return s.GetToken(YQLParserREPLACE, 0) } func (s *Create_table_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Create_table_stmtContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Create_table_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Create_table_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Create_table_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Create_table_stmtContext) Table_inherits() ITable_inheritsContext { @@ -46517,13 +46517,13 @@ func (s *Create_table_stmtContext) ToStringTree(ruleNames []string, recog antlr. func (s *Create_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_table_stmt(s) } } func (s *Create_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_table_stmt(s) } } @@ -46531,9 +46531,9 @@ func (s *Create_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtContext) { +func (p *YQLParser) Create_table_stmt() (localctx ICreate_table_stmtContext) { localctx = NewCreate_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 416, YQLv1Antlr4ParserRULE_create_table_stmt) + p.EnterRule(localctx, 416, YQLParserRULE_create_table_stmt) var _la int var _alt int @@ -46541,7 +46541,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont p.EnterOuterAlt(localctx, 1) { p.SetState(2825) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46555,10 +46555,10 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserOR { + if _la == YQLParserOR { { p.SetState(2826) - p.Match(YQLv1Antlr4ParserOR) + p.Match(YQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46566,7 +46566,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2827) - p.Match(YQLv1Antlr4ParserREPLACE) + p.Match(YQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46581,10 +46581,10 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserTABLE: + case YQLParserTABLE: { p.SetState(2830) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46592,10 +46592,10 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } - case YQLv1Antlr4ParserTABLESTORE: + case YQLParserTABLESTORE: { p.SetState(2831) - p.Match(YQLv1Antlr4ParserTABLESTORE) + p.Match(YQLParserTABLESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46603,10 +46603,10 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } - case YQLv1Antlr4ParserEXTERNAL: + case YQLParserEXTERNAL: { p.SetState(2832) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46614,7 +46614,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2833) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46622,10 +46622,10 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } - case YQLv1Antlr4ParserTEMP: + case YQLParserTEMP: { p.SetState(2834) - p.Match(YQLv1Antlr4ParserTEMP) + p.Match(YQLParserTEMP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46633,7 +46633,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2835) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46641,10 +46641,10 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } - case YQLv1Antlr4ParserTEMPORARY: + case YQLParserTEMPORARY: { p.SetState(2836) - p.Match(YQLv1Antlr4ParserTEMPORARY) + p.Match(YQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46652,7 +46652,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2837) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46672,7 +46672,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 278, p.GetParserRuleContext()) == 1 { { p.SetState(2840) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46680,7 +46680,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2841) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46688,7 +46688,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2842) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46704,7 +46704,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2846) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46727,7 +46727,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont if _alt == 1 { { p.SetState(2848) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46758,10 +46758,10 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(2855) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46771,7 +46771,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont } { p.SetState(2858) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46785,7 +46785,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserINHERITS { + if _la == YQLParserINHERITS { { p.SetState(2859) p.Table_inherits() @@ -46800,7 +46800,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPARTITION { + if _la == YQLParserPARTITION { { p.SetState(2862) p.Table_partition_by() @@ -46815,7 +46815,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(2865) p.With_table_settings() @@ -46830,7 +46830,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserTABLESTORE { + if _la == YQLParserTABLESTORE { { p.SetState(2868) p.Table_tablestore() @@ -46845,7 +46845,7 @@ func (p *YQLv1Antlr4Parser) Create_table_stmt() (localctx ICreate_table_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAS { + if _la == YQLParserAS { { p.SetState(2871) p.Table_as_source() @@ -46896,13 +46896,13 @@ type Create_table_entryContext struct { func NewEmptyCreate_table_entryContext() *Create_table_entryContext { var p = new(Create_table_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_table_entry + p.RuleIndex = YQLParserRULE_create_table_entry return p } func InitEmptyCreate_table_entryContext(p *Create_table_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_table_entry + p.RuleIndex = YQLParserRULE_create_table_entry } func (*Create_table_entryContext) IsCreate_table_entryContext() {} @@ -46913,7 +46913,7 @@ func NewCreate_table_entryContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_table_entry + p.RuleIndex = YQLParserRULE_create_table_entry return p } @@ -47026,13 +47026,13 @@ func (s *Create_table_entryContext) ToStringTree(ruleNames []string, recog antlr func (s *Create_table_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_table_entry(s) } } func (s *Create_table_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_table_entry(s) } } @@ -47040,9 +47040,9 @@ func (s *Create_table_entryContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_table_entry() (localctx ICreate_table_entryContext) { +func (p *YQLParser) Create_table_entry() (localctx ICreate_table_entryContext) { localctx = NewCreate_table_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 418, YQLv1Antlr4ParserRULE_create_table_entry) + p.EnterRule(localctx, 418, YQLParserRULE_create_table_entry) p.SetState(2880) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -47144,13 +47144,13 @@ type Create_backup_collection_stmtContext struct { func NewEmptyCreate_backup_collection_stmtContext() *Create_backup_collection_stmtContext { var p = new(Create_backup_collection_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_stmt + p.RuleIndex = YQLParserRULE_create_backup_collection_stmt return p } func InitEmptyCreate_backup_collection_stmtContext(p *Create_backup_collection_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_stmt + p.RuleIndex = YQLParserRULE_create_backup_collection_stmt } func (*Create_backup_collection_stmtContext) IsCreate_backup_collection_stmtContext() {} @@ -47161,7 +47161,7 @@ func NewCreate_backup_collection_stmtContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_stmt + p.RuleIndex = YQLParserRULE_create_backup_collection_stmt return p } @@ -47169,7 +47169,7 @@ func NewCreate_backup_collection_stmtContext(parser antlr.Parser, parent antlr.P func (s *Create_backup_collection_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_backup_collection_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_backup_collection_stmtContext) Backup_collection() IBackup_collectionContext { @@ -47189,11 +47189,11 @@ func (s *Create_backup_collection_stmtContext) Backup_collection() IBackup_colle } func (s *Create_backup_collection_stmtContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Create_backup_collection_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Create_backup_collection_stmtContext) Backup_collection_settings() IBackup_collection_settingsContext { @@ -47213,7 +47213,7 @@ func (s *Create_backup_collection_stmtContext) Backup_collection_settings() IBac } func (s *Create_backup_collection_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Create_backup_collection_stmtContext) Create_backup_collection_entries() ICreate_backup_collection_entriesContext { @@ -47242,13 +47242,13 @@ func (s *Create_backup_collection_stmtContext) ToStringTree(ruleNames []string, func (s *Create_backup_collection_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_backup_collection_stmt(s) } } func (s *Create_backup_collection_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_backup_collection_stmt(s) } } @@ -47256,15 +47256,15 @@ func (s *Create_backup_collection_stmtContext) ExitRule(listener antlr.ParseTree -func (p *YQLv1Antlr4Parser) Create_backup_collection_stmt() (localctx ICreate_backup_collection_stmtContext) { +func (p *YQLParser) Create_backup_collection_stmt() (localctx ICreate_backup_collection_stmtContext) { localctx = NewCreate_backup_collection_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 420, YQLv1Antlr4ParserRULE_create_backup_collection_stmt) + p.EnterRule(localctx, 420, YQLParserRULE_create_backup_collection_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2882) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47282,7 +47282,7 @@ func (p *YQLv1Antlr4Parser) Create_backup_collection_stmt() (localctx ICreate_ba _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLPAREN || _la == YQLv1Antlr4ParserDATABASE { + if _la == YQLParserLPAREN || _la == YQLParserDATABASE { { p.SetState(2884) p.Create_backup_collection_entries() @@ -47291,7 +47291,7 @@ func (p *YQLv1Antlr4Parser) Create_backup_collection_stmt() (localctx ICreate_ba } { p.SetState(2887) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47299,7 +47299,7 @@ func (p *YQLv1Antlr4Parser) Create_backup_collection_stmt() (localctx ICreate_ba } { p.SetState(2888) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47311,7 +47311,7 @@ func (p *YQLv1Antlr4Parser) Create_backup_collection_stmt() (localctx ICreate_ba } { p.SetState(2890) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47359,13 +47359,13 @@ type Alter_backup_collection_stmtContext struct { func NewEmptyAlter_backup_collection_stmtContext() *Alter_backup_collection_stmtContext { var p = new(Alter_backup_collection_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_stmt + p.RuleIndex = YQLParserRULE_alter_backup_collection_stmt return p } func InitEmptyAlter_backup_collection_stmtContext(p *Alter_backup_collection_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_stmt + p.RuleIndex = YQLParserRULE_alter_backup_collection_stmt } func (*Alter_backup_collection_stmtContext) IsAlter_backup_collection_stmtContext() {} @@ -47376,7 +47376,7 @@ func NewAlter_backup_collection_stmtContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_stmt + p.RuleIndex = YQLParserRULE_alter_backup_collection_stmt return p } @@ -47384,7 +47384,7 @@ func NewAlter_backup_collection_stmtContext(parser antlr.Parser, parent antlr.Pa func (s *Alter_backup_collection_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_backup_collection_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_backup_collection_stmtContext) Backup_collection() IBackup_collectionContext { @@ -47445,13 +47445,13 @@ func (s *Alter_backup_collection_stmtContext) ToStringTree(ruleNames []string, r func (s *Alter_backup_collection_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_backup_collection_stmt(s) } } func (s *Alter_backup_collection_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_backup_collection_stmt(s) } } @@ -47459,13 +47459,13 @@ func (s *Alter_backup_collection_stmtContext) ExitRule(listener antlr.ParseTreeL -func (p *YQLv1Antlr4Parser) Alter_backup_collection_stmt() (localctx IAlter_backup_collection_stmtContext) { +func (p *YQLParser) Alter_backup_collection_stmt() (localctx IAlter_backup_collection_stmtContext) { localctx = NewAlter_backup_collection_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 422, YQLv1Antlr4ParserRULE_alter_backup_collection_stmt) + p.EnterRule(localctx, 422, YQLParserRULE_alter_backup_collection_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2892) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47482,14 +47482,14 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_stmt() (localctx IAlter_back } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserSET: + case YQLParserRESET, YQLParserSET: { p.SetState(2894) p.Alter_backup_collection_actions() } - case YQLv1Antlr4ParserADD, YQLv1Antlr4ParserDROP: + case YQLParserADD, YQLParserDROP: { p.SetState(2895) p.Alter_backup_collection_entries() @@ -47541,13 +47541,13 @@ type Drop_backup_collection_stmtContext struct { func NewEmptyDrop_backup_collection_stmtContext() *Drop_backup_collection_stmtContext { var p = new(Drop_backup_collection_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_backup_collection_stmt + p.RuleIndex = YQLParserRULE_drop_backup_collection_stmt return p } func InitEmptyDrop_backup_collection_stmtContext(p *Drop_backup_collection_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_backup_collection_stmt + p.RuleIndex = YQLParserRULE_drop_backup_collection_stmt } func (*Drop_backup_collection_stmtContext) IsDrop_backup_collection_stmtContext() {} @@ -47558,7 +47558,7 @@ func NewDrop_backup_collection_stmtContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_backup_collection_stmt + p.RuleIndex = YQLParserRULE_drop_backup_collection_stmt return p } @@ -47566,7 +47566,7 @@ func NewDrop_backup_collection_stmtContext(parser antlr.Parser, parent antlr.Par func (s *Drop_backup_collection_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_backup_collection_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_backup_collection_stmtContext) Backup_collection() IBackup_collectionContext { @@ -47595,13 +47595,13 @@ func (s *Drop_backup_collection_stmtContext) ToStringTree(ruleNames []string, re func (s *Drop_backup_collection_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_backup_collection_stmt(s) } } func (s *Drop_backup_collection_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_backup_collection_stmt(s) } } @@ -47609,13 +47609,13 @@ func (s *Drop_backup_collection_stmtContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Drop_backup_collection_stmt() (localctx IDrop_backup_collection_stmtContext) { +func (p *YQLParser) Drop_backup_collection_stmt() (localctx IDrop_backup_collection_stmtContext) { localctx = NewDrop_backup_collection_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 424, YQLv1Antlr4ParserRULE_drop_backup_collection_stmt) + p.EnterRule(localctx, 424, YQLParserRULE_drop_backup_collection_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2898) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47665,13 +47665,13 @@ type Create_backup_collection_entriesContext struct { func NewEmptyCreate_backup_collection_entriesContext() *Create_backup_collection_entriesContext { var p = new(Create_backup_collection_entriesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_entries + p.RuleIndex = YQLParserRULE_create_backup_collection_entries return p } func InitEmptyCreate_backup_collection_entriesContext(p *Create_backup_collection_entriesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_entries + p.RuleIndex = YQLParserRULE_create_backup_collection_entries } func (*Create_backup_collection_entriesContext) IsCreate_backup_collection_entriesContext() {} @@ -47682,7 +47682,7 @@ func NewCreate_backup_collection_entriesContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_entries + p.RuleIndex = YQLParserRULE_create_backup_collection_entries return p } @@ -47690,7 +47690,7 @@ func NewCreate_backup_collection_entriesContext(parser antlr.Parser, parent antl func (s *Create_backup_collection_entriesContext) GetParser() antlr.Parser { return s.parser } func (s *Create_backup_collection_entriesContext) DATABASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATABASE, 0) + return s.GetToken(YQLParserDATABASE, 0) } func (s *Create_backup_collection_entriesContext) Create_backup_collection_entries_many() ICreate_backup_collection_entries_manyContext { @@ -47719,13 +47719,13 @@ func (s *Create_backup_collection_entriesContext) ToStringTree(ruleNames []strin func (s *Create_backup_collection_entriesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_backup_collection_entries(s) } } func (s *Create_backup_collection_entriesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_backup_collection_entries(s) } } @@ -47733,9 +47733,9 @@ func (s *Create_backup_collection_entriesContext) ExitRule(listener antlr.ParseT -func (p *YQLv1Antlr4Parser) Create_backup_collection_entries() (localctx ICreate_backup_collection_entriesContext) { +func (p *YQLParser) Create_backup_collection_entries() (localctx ICreate_backup_collection_entriesContext) { localctx = NewCreate_backup_collection_entriesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 426, YQLv1Antlr4ParserRULE_create_backup_collection_entries) + p.EnterRule(localctx, 426, YQLParserRULE_create_backup_collection_entries) p.SetState(2903) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -47743,11 +47743,11 @@ func (p *YQLv1Antlr4Parser) Create_backup_collection_entries() (localctx ICreate } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDATABASE: + case YQLParserDATABASE: p.EnterOuterAlt(localctx, 1) { p.SetState(2901) - p.Match(YQLv1Antlr4ParserDATABASE) + p.Match(YQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47755,7 +47755,7 @@ func (p *YQLv1Antlr4Parser) Create_backup_collection_entries() (localctx ICreate } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(2902) @@ -47808,13 +47808,13 @@ type Create_backup_collection_entries_manyContext struct { func NewEmptyCreate_backup_collection_entries_manyContext() *Create_backup_collection_entries_manyContext { var p = new(Create_backup_collection_entries_manyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_entries_many + p.RuleIndex = YQLParserRULE_create_backup_collection_entries_many return p } func InitEmptyCreate_backup_collection_entries_manyContext(p *Create_backup_collection_entries_manyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_entries_many + p.RuleIndex = YQLParserRULE_create_backup_collection_entries_many } func (*Create_backup_collection_entries_manyContext) IsCreate_backup_collection_entries_manyContext() {} @@ -47825,7 +47825,7 @@ func NewCreate_backup_collection_entries_manyContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_backup_collection_entries_many + p.RuleIndex = YQLParserRULE_create_backup_collection_entries_many return p } @@ -47833,7 +47833,7 @@ func NewCreate_backup_collection_entries_manyContext(parser antlr.Parser, parent func (s *Create_backup_collection_entries_manyContext) GetParser() antlr.Parser { return s.parser } func (s *Create_backup_collection_entries_manyContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Create_backup_collection_entries_manyContext) Table_list() ITable_listContext { @@ -47853,7 +47853,7 @@ func (s *Create_backup_collection_entries_manyContext) Table_list() ITable_listC } func (s *Create_backup_collection_entries_manyContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Create_backup_collection_entries_manyContext) GetRuleContext() antlr.RuleContext { @@ -47866,13 +47866,13 @@ func (s *Create_backup_collection_entries_manyContext) ToStringTree(ruleNames [] func (s *Create_backup_collection_entries_manyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_backup_collection_entries_many(s) } } func (s *Create_backup_collection_entries_manyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_backup_collection_entries_many(s) } } @@ -47880,13 +47880,13 @@ func (s *Create_backup_collection_entries_manyContext) ExitRule(listener antlr.P -func (p *YQLv1Antlr4Parser) Create_backup_collection_entries_many() (localctx ICreate_backup_collection_entries_manyContext) { +func (p *YQLParser) Create_backup_collection_entries_many() (localctx ICreate_backup_collection_entries_manyContext) { localctx = NewCreate_backup_collection_entries_manyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 428, YQLv1Antlr4ParserRULE_create_backup_collection_entries_many) + p.EnterRule(localctx, 428, YQLParserRULE_create_backup_collection_entries_many) p.EnterOuterAlt(localctx, 1) { p.SetState(2905) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47898,7 +47898,7 @@ func (p *YQLv1Antlr4Parser) Create_backup_collection_entries_many() (localctx IC } { p.SetState(2907) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47948,13 +47948,13 @@ type Table_listContext struct { func NewEmptyTable_listContext() *Table_listContext { var p = new(Table_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_list + p.RuleIndex = YQLParserRULE_table_list return p } func InitEmptyTable_listContext(p *Table_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_list + p.RuleIndex = YQLParserRULE_table_list } func (*Table_listContext) IsTable_listContext() {} @@ -47965,7 +47965,7 @@ func NewTable_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_list + p.RuleIndex = YQLParserRULE_table_list return p } @@ -47973,11 +47973,11 @@ func NewTable_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *Table_listContext) GetParser() antlr.Parser { return s.parser } func (s *Table_listContext) AllTABLE() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserTABLE) + return s.GetTokens(YQLParserTABLE) } func (s *Table_listContext) TABLE(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, i) + return s.GetToken(YQLParserTABLE, i) } func (s *Table_listContext) AllAn_id_table() []IAn_id_tableContext { @@ -48022,11 +48022,11 @@ func (s *Table_listContext) An_id_table(i int) IAn_id_tableContext { } func (s *Table_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Table_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Table_listContext) GetRuleContext() antlr.RuleContext { @@ -48039,13 +48039,13 @@ func (s *Table_listContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Table_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_list(s) } } func (s *Table_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_list(s) } } @@ -48053,15 +48053,15 @@ func (s *Table_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_list() (localctx ITable_listContext) { +func (p *YQLParser) Table_list() (localctx ITable_listContext) { localctx = NewTable_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 430, YQLv1Antlr4ParserRULE_table_list) + p.EnterRule(localctx, 430, YQLParserRULE_table_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2909) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48079,10 +48079,10 @@ func (p *YQLv1Antlr4Parser) Table_list() (localctx ITable_listContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2911) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48090,7 +48090,7 @@ func (p *YQLv1Antlr4Parser) Table_list() (localctx ITable_listContext) { } { p.SetState(2912) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48151,13 +48151,13 @@ type Alter_backup_collection_actionsContext struct { func NewEmptyAlter_backup_collection_actionsContext() *Alter_backup_collection_actionsContext { var p = new(Alter_backup_collection_actionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_actions + p.RuleIndex = YQLParserRULE_alter_backup_collection_actions return p } func InitEmptyAlter_backup_collection_actionsContext(p *Alter_backup_collection_actionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_actions + p.RuleIndex = YQLParserRULE_alter_backup_collection_actions } func (*Alter_backup_collection_actionsContext) IsAlter_backup_collection_actionsContext() {} @@ -48168,7 +48168,7 @@ func NewAlter_backup_collection_actionsContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_actions + p.RuleIndex = YQLParserRULE_alter_backup_collection_actions return p } @@ -48217,11 +48217,11 @@ func (s *Alter_backup_collection_actionsContext) Alter_backup_collection_action( } func (s *Alter_backup_collection_actionsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_backup_collection_actionsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_backup_collection_actionsContext) GetRuleContext() antlr.RuleContext { @@ -48234,13 +48234,13 @@ func (s *Alter_backup_collection_actionsContext) ToStringTree(ruleNames []string func (s *Alter_backup_collection_actionsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_backup_collection_actions(s) } } func (s *Alter_backup_collection_actionsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_backup_collection_actions(s) } } @@ -48248,9 +48248,9 @@ func (s *Alter_backup_collection_actionsContext) ExitRule(listener antlr.ParseTr -func (p *YQLv1Antlr4Parser) Alter_backup_collection_actions() (localctx IAlter_backup_collection_actionsContext) { +func (p *YQLParser) Alter_backup_collection_actions() (localctx IAlter_backup_collection_actionsContext) { localctx = NewAlter_backup_collection_actionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 432, YQLv1Antlr4ParserRULE_alter_backup_collection_actions) + p.EnterRule(localctx, 432, YQLParserRULE_alter_backup_collection_actions) var _la int p.EnterOuterAlt(localctx, 1) @@ -48266,10 +48266,10 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_actions() (localctx IAlter_b _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2920) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48328,13 +48328,13 @@ type Alter_backup_collection_actionContext struct { func NewEmptyAlter_backup_collection_actionContext() *Alter_backup_collection_actionContext { var p = new(Alter_backup_collection_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_action + p.RuleIndex = YQLParserRULE_alter_backup_collection_action return p } func InitEmptyAlter_backup_collection_actionContext(p *Alter_backup_collection_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_action + p.RuleIndex = YQLParserRULE_alter_backup_collection_action } func (*Alter_backup_collection_actionContext) IsAlter_backup_collection_actionContext() {} @@ -48345,7 +48345,7 @@ func NewAlter_backup_collection_actionContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_action + p.RuleIndex = YQLParserRULE_alter_backup_collection_action return p } @@ -48394,13 +48394,13 @@ func (s *Alter_backup_collection_actionContext) ToStringTree(ruleNames []string, func (s *Alter_backup_collection_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_backup_collection_action(s) } } func (s *Alter_backup_collection_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_backup_collection_action(s) } } @@ -48408,9 +48408,9 @@ func (s *Alter_backup_collection_actionContext) ExitRule(listener antlr.ParseTre -func (p *YQLv1Antlr4Parser) Alter_backup_collection_action() (localctx IAlter_backup_collection_actionContext) { +func (p *YQLParser) Alter_backup_collection_action() (localctx IAlter_backup_collection_actionContext) { localctx = NewAlter_backup_collection_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 434, YQLv1Antlr4ParserRULE_alter_backup_collection_action) + p.EnterRule(localctx, 434, YQLParserRULE_alter_backup_collection_action) p.SetState(2929) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -48418,7 +48418,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_action() (localctx IAlter_ba } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSET: + case YQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(2927) @@ -48426,7 +48426,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_action() (localctx IAlter_ba } - case YQLv1Antlr4ParserRESET: + case YQLParserRESET: p.EnterOuterAlt(localctx, 2) { p.SetState(2928) @@ -48480,13 +48480,13 @@ type Alter_backup_collection_entriesContext struct { func NewEmptyAlter_backup_collection_entriesContext() *Alter_backup_collection_entriesContext { var p = new(Alter_backup_collection_entriesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_entries + p.RuleIndex = YQLParserRULE_alter_backup_collection_entries return p } func InitEmptyAlter_backup_collection_entriesContext(p *Alter_backup_collection_entriesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_entries + p.RuleIndex = YQLParserRULE_alter_backup_collection_entries } func (*Alter_backup_collection_entriesContext) IsAlter_backup_collection_entriesContext() {} @@ -48497,7 +48497,7 @@ func NewAlter_backup_collection_entriesContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_entries + p.RuleIndex = YQLParserRULE_alter_backup_collection_entries return p } @@ -48546,11 +48546,11 @@ func (s *Alter_backup_collection_entriesContext) Alter_backup_collection_entry(i } func (s *Alter_backup_collection_entriesContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_backup_collection_entriesContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_backup_collection_entriesContext) GetRuleContext() antlr.RuleContext { @@ -48563,13 +48563,13 @@ func (s *Alter_backup_collection_entriesContext) ToStringTree(ruleNames []string func (s *Alter_backup_collection_entriesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_backup_collection_entries(s) } } func (s *Alter_backup_collection_entriesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_backup_collection_entries(s) } } @@ -48577,9 +48577,9 @@ func (s *Alter_backup_collection_entriesContext) ExitRule(listener antlr.ParseTr -func (p *YQLv1Antlr4Parser) Alter_backup_collection_entries() (localctx IAlter_backup_collection_entriesContext) { +func (p *YQLParser) Alter_backup_collection_entries() (localctx IAlter_backup_collection_entriesContext) { localctx = NewAlter_backup_collection_entriesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 436, YQLv1Antlr4ParserRULE_alter_backup_collection_entries) + p.EnterRule(localctx, 436, YQLParserRULE_alter_backup_collection_entries) var _la int p.EnterOuterAlt(localctx, 1) @@ -48595,10 +48595,10 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entries() (localctx IAlter_b _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2932) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48660,13 +48660,13 @@ type Alter_backup_collection_entryContext struct { func NewEmptyAlter_backup_collection_entryContext() *Alter_backup_collection_entryContext { var p = new(Alter_backup_collection_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_entry + p.RuleIndex = YQLParserRULE_alter_backup_collection_entry return p } func InitEmptyAlter_backup_collection_entryContext(p *Alter_backup_collection_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_entry + p.RuleIndex = YQLParserRULE_alter_backup_collection_entry } func (*Alter_backup_collection_entryContext) IsAlter_backup_collection_entryContext() {} @@ -48677,7 +48677,7 @@ func NewAlter_backup_collection_entryContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_backup_collection_entry + p.RuleIndex = YQLParserRULE_alter_backup_collection_entry return p } @@ -48685,19 +48685,19 @@ func NewAlter_backup_collection_entryContext(parser antlr.Parser, parent antlr.P func (s *Alter_backup_collection_entryContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_backup_collection_entryContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Alter_backup_collection_entryContext) DATABASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATABASE, 0) + return s.GetToken(YQLParserDATABASE, 0) } func (s *Alter_backup_collection_entryContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Alter_backup_collection_entryContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Alter_backup_collection_entryContext) An_id_table() IAn_id_tableContext { @@ -48726,13 +48726,13 @@ func (s *Alter_backup_collection_entryContext) ToStringTree(ruleNames []string, func (s *Alter_backup_collection_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_backup_collection_entry(s) } } func (s *Alter_backup_collection_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_backup_collection_entry(s) } } @@ -48740,9 +48740,9 @@ func (s *Alter_backup_collection_entryContext) ExitRule(listener antlr.ParseTree -func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_backup_collection_entryContext) { +func (p *YQLParser) Alter_backup_collection_entry() (localctx IAlter_backup_collection_entryContext) { localctx = NewAlter_backup_collection_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 438, YQLv1Antlr4ParserRULE_alter_backup_collection_entry) + p.EnterRule(localctx, 438, YQLParserRULE_alter_backup_collection_entry) p.SetState(2949) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -48754,7 +48754,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac p.EnterOuterAlt(localctx, 1) { p.SetState(2939) - p.Match(YQLv1Antlr4ParserADD) + p.Match(YQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48762,7 +48762,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac } { p.SetState(2940) - p.Match(YQLv1Antlr4ParserDATABASE) + p.Match(YQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48774,7 +48774,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac p.EnterOuterAlt(localctx, 2) { p.SetState(2941) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48782,7 +48782,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac } { p.SetState(2942) - p.Match(YQLv1Antlr4ParserDATABASE) + p.Match(YQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48794,7 +48794,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac p.EnterOuterAlt(localctx, 3) { p.SetState(2943) - p.Match(YQLv1Antlr4ParserADD) + p.Match(YQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48802,7 +48802,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac } { p.SetState(2944) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48818,7 +48818,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac p.EnterOuterAlt(localctx, 4) { p.SetState(2946) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48826,7 +48826,7 @@ func (p *YQLv1Antlr4Parser) Alter_backup_collection_entry() (localctx IAlter_bac } { p.SetState(2947) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48880,13 +48880,13 @@ type Backup_collectionContext struct { func NewEmptyBackup_collectionContext() *Backup_collectionContext { var p = new(Backup_collectionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection + p.RuleIndex = YQLParserRULE_backup_collection return p } func InitEmptyBackup_collectionContext(p *Backup_collectionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection + p.RuleIndex = YQLParserRULE_backup_collection } func (*Backup_collectionContext) IsBackup_collectionContext() {} @@ -48897,7 +48897,7 @@ func NewBackup_collectionContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection + p.RuleIndex = YQLParserRULE_backup_collection return p } @@ -48905,11 +48905,11 @@ func NewBackup_collectionContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Backup_collectionContext) GetParser() antlr.Parser { return s.parser } func (s *Backup_collectionContext) BACKUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBACKUP, 0) + return s.GetToken(YQLParserBACKUP, 0) } func (s *Backup_collectionContext) COLLECTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLLECTION, 0) + return s.GetToken(YQLParserCOLLECTION, 0) } func (s *Backup_collectionContext) Object_ref() IObject_refContext { @@ -48938,13 +48938,13 @@ func (s *Backup_collectionContext) ToStringTree(ruleNames []string, recog antlr. func (s *Backup_collectionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBackup_collection(s) } } func (s *Backup_collectionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBackup_collection(s) } } @@ -48952,13 +48952,13 @@ func (s *Backup_collectionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Backup_collection() (localctx IBackup_collectionContext) { +func (p *YQLParser) Backup_collection() (localctx IBackup_collectionContext) { localctx = NewBackup_collectionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 440, YQLv1Antlr4ParserRULE_backup_collection) + p.EnterRule(localctx, 440, YQLParserRULE_backup_collection) p.EnterOuterAlt(localctx, 1) { p.SetState(2951) - p.Match(YQLv1Antlr4ParserBACKUP) + p.Match(YQLParserBACKUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48966,7 +48966,7 @@ func (p *YQLv1Antlr4Parser) Backup_collection() (localctx IBackup_collectionCont } { p.SetState(2952) - p.Match(YQLv1Antlr4ParserCOLLECTION) + p.Match(YQLParserCOLLECTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49018,13 +49018,13 @@ type Backup_collection_settingsContext struct { func NewEmptyBackup_collection_settingsContext() *Backup_collection_settingsContext { var p = new(Backup_collection_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection_settings + p.RuleIndex = YQLParserRULE_backup_collection_settings return p } func InitEmptyBackup_collection_settingsContext(p *Backup_collection_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection_settings + p.RuleIndex = YQLParserRULE_backup_collection_settings } func (*Backup_collection_settingsContext) IsBackup_collection_settingsContext() {} @@ -49035,7 +49035,7 @@ func NewBackup_collection_settingsContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection_settings + p.RuleIndex = YQLParserRULE_backup_collection_settings return p } @@ -49084,11 +49084,11 @@ func (s *Backup_collection_settingsContext) Backup_collection_settings_entry(i i } func (s *Backup_collection_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Backup_collection_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Backup_collection_settingsContext) GetRuleContext() antlr.RuleContext { @@ -49101,13 +49101,13 @@ func (s *Backup_collection_settingsContext) ToStringTree(ruleNames []string, rec func (s *Backup_collection_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBackup_collection_settings(s) } } func (s *Backup_collection_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBackup_collection_settings(s) } } @@ -49115,9 +49115,9 @@ func (s *Backup_collection_settingsContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Backup_collection_settings() (localctx IBackup_collection_settingsContext) { +func (p *YQLParser) Backup_collection_settings() (localctx IBackup_collection_settingsContext) { localctx = NewBackup_collection_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 442, YQLv1Antlr4ParserRULE_backup_collection_settings) + p.EnterRule(localctx, 442, YQLParserRULE_backup_collection_settings) var _la int p.EnterOuterAlt(localctx, 1) @@ -49133,10 +49133,10 @@ func (p *YQLv1Antlr4Parser) Backup_collection_settings() (localctx IBackup_colle _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2956) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49196,13 +49196,13 @@ type Backup_collection_settings_entryContext struct { func NewEmptyBackup_collection_settings_entryContext() *Backup_collection_settings_entryContext { var p = new(Backup_collection_settings_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection_settings_entry + p.RuleIndex = YQLParserRULE_backup_collection_settings_entry return p } func InitEmptyBackup_collection_settings_entryContext(p *Backup_collection_settings_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection_settings_entry + p.RuleIndex = YQLParserRULE_backup_collection_settings_entry } func (*Backup_collection_settings_entryContext) IsBackup_collection_settings_entryContext() {} @@ -49213,7 +49213,7 @@ func NewBackup_collection_settings_entryContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_collection_settings_entry + p.RuleIndex = YQLParserRULE_backup_collection_settings_entry return p } @@ -49237,7 +49237,7 @@ func (s *Backup_collection_settings_entryContext) An_id() IAn_idContext { } func (s *Backup_collection_settings_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Backup_collection_settings_entryContext) Table_setting_value() ITable_setting_valueContext { @@ -49266,13 +49266,13 @@ func (s *Backup_collection_settings_entryContext) ToStringTree(ruleNames []strin func (s *Backup_collection_settings_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBackup_collection_settings_entry(s) } } func (s *Backup_collection_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBackup_collection_settings_entry(s) } } @@ -49280,9 +49280,9 @@ func (s *Backup_collection_settings_entryContext) ExitRule(listener antlr.ParseT -func (p *YQLv1Antlr4Parser) Backup_collection_settings_entry() (localctx IBackup_collection_settings_entryContext) { +func (p *YQLParser) Backup_collection_settings_entry() (localctx IBackup_collection_settings_entryContext) { localctx = NewBackup_collection_settings_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 444, YQLv1Antlr4ParserRULE_backup_collection_settings_entry) + p.EnterRule(localctx, 444, YQLParserRULE_backup_collection_settings_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(2963) @@ -49290,7 +49290,7 @@ func (p *YQLv1Antlr4Parser) Backup_collection_settings_entry() (localctx IBackup } { p.SetState(2964) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49341,13 +49341,13 @@ type Backup_stmtContext struct { func NewEmptyBackup_stmtContext() *Backup_stmtContext { var p = new(Backup_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_stmt + p.RuleIndex = YQLParserRULE_backup_stmt return p } func InitEmptyBackup_stmtContext(p *Backup_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_stmt + p.RuleIndex = YQLParserRULE_backup_stmt } func (*Backup_stmtContext) IsBackup_stmtContext() {} @@ -49358,7 +49358,7 @@ func NewBackup_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_backup_stmt + p.RuleIndex = YQLParserRULE_backup_stmt return p } @@ -49366,7 +49366,7 @@ func NewBackup_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Backup_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Backup_stmtContext) BACKUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBACKUP, 0) + return s.GetToken(YQLParserBACKUP, 0) } func (s *Backup_stmtContext) Object_ref() IObject_refContext { @@ -49386,7 +49386,7 @@ func (s *Backup_stmtContext) Object_ref() IObject_refContext { } func (s *Backup_stmtContext) INCREMENTAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINCREMENTAL, 0) + return s.GetToken(YQLParserINCREMENTAL, 0) } func (s *Backup_stmtContext) GetRuleContext() antlr.RuleContext { @@ -49399,13 +49399,13 @@ func (s *Backup_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Backup_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBackup_stmt(s) } } func (s *Backup_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBackup_stmt(s) } } @@ -49413,15 +49413,15 @@ func (s *Backup_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Backup_stmt() (localctx IBackup_stmtContext) { +func (p *YQLParser) Backup_stmt() (localctx IBackup_stmtContext) { localctx = NewBackup_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 446, YQLv1Antlr4ParserRULE_backup_stmt) + p.EnterRule(localctx, 446, YQLParserRULE_backup_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2967) - p.Match(YQLv1Antlr4ParserBACKUP) + p.Match(YQLParserBACKUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49439,10 +49439,10 @@ func (p *YQLv1Antlr4Parser) Backup_stmt() (localctx IBackup_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserINCREMENTAL { + if _la == YQLParserINCREMENTAL { { p.SetState(2969) - p.Match(YQLv1Antlr4ParserINCREMENTAL) + p.Match(YQLParserINCREMENTAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49492,13 +49492,13 @@ type Restore_stmtContext struct { func NewEmptyRestore_stmtContext() *Restore_stmtContext { var p = new(Restore_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_restore_stmt + p.RuleIndex = YQLParserRULE_restore_stmt return p } func InitEmptyRestore_stmtContext(p *Restore_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_restore_stmt + p.RuleIndex = YQLParserRULE_restore_stmt } func (*Restore_stmtContext) IsRestore_stmtContext() {} @@ -49509,7 +49509,7 @@ func NewRestore_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_restore_stmt + p.RuleIndex = YQLParserRULE_restore_stmt return p } @@ -49517,7 +49517,7 @@ func NewRestore_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Restore_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Restore_stmtContext) RESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTORE, 0) + return s.GetToken(YQLParserRESTORE, 0) } func (s *Restore_stmtContext) Object_ref() IObject_refContext { @@ -49537,11 +49537,11 @@ func (s *Restore_stmtContext) Object_ref() IObject_refContext { } func (s *Restore_stmtContext) AT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAT, 0) + return s.GetToken(YQLParserAT, 0) } func (s *Restore_stmtContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Restore_stmtContext) GetRuleContext() antlr.RuleContext { @@ -49554,13 +49554,13 @@ func (s *Restore_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Restore_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRestore_stmt(s) } } func (s *Restore_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRestore_stmt(s) } } @@ -49568,15 +49568,15 @@ func (s *Restore_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Restore_stmt() (localctx IRestore_stmtContext) { +func (p *YQLParser) Restore_stmt() (localctx IRestore_stmtContext) { localctx = NewRestore_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 448, YQLv1Antlr4ParserRULE_restore_stmt) + p.EnterRule(localctx, 448, YQLParserRULE_restore_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2972) - p.Match(YQLv1Antlr4ParserRESTORE) + p.Match(YQLParserRESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49594,10 +49594,10 @@ func (p *YQLv1Antlr4Parser) Restore_stmt() (localctx IRestore_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAT { + if _la == YQLParserAT { { p.SetState(2974) - p.Match(YQLv1Antlr4ParserAT) + p.Match(YQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49605,7 +49605,7 @@ func (p *YQLv1Antlr4Parser) Restore_stmt() (localctx IRestore_stmtContext) { } { p.SetState(2975) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49658,13 +49658,13 @@ type Table_inheritsContext struct { func NewEmptyTable_inheritsContext() *Table_inheritsContext { var p = new(Table_inheritsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_inherits + p.RuleIndex = YQLParserRULE_table_inherits return p } func InitEmptyTable_inheritsContext(p *Table_inheritsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_inherits + p.RuleIndex = YQLParserRULE_table_inherits } func (*Table_inheritsContext) IsTable_inheritsContext() {} @@ -49675,7 +49675,7 @@ func NewTable_inheritsContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_inherits + p.RuleIndex = YQLParserRULE_table_inherits return p } @@ -49683,11 +49683,11 @@ func NewTable_inheritsContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Table_inheritsContext) GetParser() antlr.Parser { return s.parser } func (s *Table_inheritsContext) INHERITS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINHERITS, 0) + return s.GetToken(YQLParserINHERITS, 0) } func (s *Table_inheritsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Table_inheritsContext) AllSimple_table_ref_core() []ISimple_table_ref_coreContext { @@ -49732,15 +49732,15 @@ func (s *Table_inheritsContext) Simple_table_ref_core(i int) ISimple_table_ref_c } func (s *Table_inheritsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Table_inheritsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Table_inheritsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Table_inheritsContext) GetRuleContext() antlr.RuleContext { @@ -49753,13 +49753,13 @@ func (s *Table_inheritsContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Table_inheritsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_inherits(s) } } func (s *Table_inheritsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_inherits(s) } } @@ -49767,15 +49767,15 @@ func (s *Table_inheritsContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_inherits() (localctx ITable_inheritsContext) { +func (p *YQLParser) Table_inherits() (localctx ITable_inheritsContext) { localctx = NewTable_inheritsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 450, YQLv1Antlr4ParserRULE_table_inherits) + p.EnterRule(localctx, 450, YQLParserRULE_table_inherits) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2978) - p.Match(YQLv1Antlr4ParserINHERITS) + p.Match(YQLParserINHERITS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49783,7 +49783,7 @@ func (p *YQLv1Antlr4Parser) Table_inherits() (localctx ITable_inheritsContext) { } { p.SetState(2979) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49801,10 +49801,10 @@ func (p *YQLv1Antlr4Parser) Table_inherits() (localctx ITable_inheritsContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2981) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49825,7 +49825,7 @@ func (p *YQLv1Antlr4Parser) Table_inherits() (localctx ITable_inheritsContext) { } { p.SetState(2988) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49873,13 +49873,13 @@ type Table_partition_byContext struct { func NewEmptyTable_partition_byContext() *Table_partition_byContext { var p = new(Table_partition_byContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_partition_by + p.RuleIndex = YQLParserRULE_table_partition_by return p } func InitEmptyTable_partition_byContext(p *Table_partition_byContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_partition_by + p.RuleIndex = YQLParserRULE_table_partition_by } func (*Table_partition_byContext) IsTable_partition_byContext() {} @@ -49890,7 +49890,7 @@ func NewTable_partition_byContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_partition_by + p.RuleIndex = YQLParserRULE_table_partition_by return p } @@ -49898,15 +49898,15 @@ func NewTable_partition_byContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Table_partition_byContext) GetParser() antlr.Parser { return s.parser } func (s *Table_partition_byContext) PARTITION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARTITION, 0) + return s.GetToken(YQLParserPARTITION, 0) } func (s *Table_partition_byContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Table_partition_byContext) HASH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHASH, 0) + return s.GetToken(YQLParserHASH, 0) } func (s *Table_partition_byContext) Pure_column_list() IPure_column_listContext { @@ -49935,13 +49935,13 @@ func (s *Table_partition_byContext) ToStringTree(ruleNames []string, recog antlr func (s *Table_partition_byContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_partition_by(s) } } func (s *Table_partition_byContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_partition_by(s) } } @@ -49949,13 +49949,13 @@ func (s *Table_partition_byContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_partition_by() (localctx ITable_partition_byContext) { +func (p *YQLParser) Table_partition_by() (localctx ITable_partition_byContext) { localctx = NewTable_partition_byContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 452, YQLv1Antlr4ParserRULE_table_partition_by) + p.EnterRule(localctx, 452, YQLParserRULE_table_partition_by) p.EnterOuterAlt(localctx, 1) { p.SetState(2990) - p.Match(YQLv1Antlr4ParserPARTITION) + p.Match(YQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49963,7 +49963,7 @@ func (p *YQLv1Antlr4Parser) Table_partition_by() (localctx ITable_partition_byCo } { p.SetState(2991) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49971,7 +49971,7 @@ func (p *YQLv1Antlr4Parser) Table_partition_by() (localctx ITable_partition_byCo } { p.SetState(2992) - p.Match(YQLv1Antlr4ParserHASH) + p.Match(YQLParserHASH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50026,13 +50026,13 @@ type With_table_settingsContext struct { func NewEmptyWith_table_settingsContext() *With_table_settingsContext { var p = new(With_table_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_with_table_settings + p.RuleIndex = YQLParserRULE_with_table_settings return p } func InitEmptyWith_table_settingsContext(p *With_table_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_with_table_settings + p.RuleIndex = YQLParserRULE_with_table_settings } func (*With_table_settingsContext) IsWith_table_settingsContext() {} @@ -50043,7 +50043,7 @@ func NewWith_table_settingsContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_with_table_settings + p.RuleIndex = YQLParserRULE_with_table_settings return p } @@ -50051,11 +50051,11 @@ func NewWith_table_settingsContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *With_table_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *With_table_settingsContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *With_table_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *With_table_settingsContext) AllTable_settings_entry() []ITable_settings_entryContext { @@ -50100,15 +50100,15 @@ func (s *With_table_settingsContext) Table_settings_entry(i int) ITable_settings } func (s *With_table_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *With_table_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *With_table_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *With_table_settingsContext) GetRuleContext() antlr.RuleContext { @@ -50121,13 +50121,13 @@ func (s *With_table_settingsContext) ToStringTree(ruleNames []string, recog antl func (s *With_table_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWith_table_settings(s) } } func (s *With_table_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWith_table_settings(s) } } @@ -50135,15 +50135,15 @@ func (s *With_table_settingsContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) With_table_settings() (localctx IWith_table_settingsContext) { +func (p *YQLParser) With_table_settings() (localctx IWith_table_settingsContext) { localctx = NewWith_table_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 454, YQLv1Antlr4ParserRULE_with_table_settings) + p.EnterRule(localctx, 454, YQLParserRULE_with_table_settings) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2995) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50151,7 +50151,7 @@ func (p *YQLv1Antlr4Parser) With_table_settings() (localctx IWith_table_settings } { p.SetState(2996) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50169,10 +50169,10 @@ func (p *YQLv1Antlr4Parser) With_table_settings() (localctx IWith_table_settings _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(2998) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50193,7 +50193,7 @@ func (p *YQLv1Antlr4Parser) With_table_settings() (localctx IWith_table_settings } { p.SetState(3005) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50239,13 +50239,13 @@ type Table_tablestoreContext struct { func NewEmptyTable_tablestoreContext() *Table_tablestoreContext { var p = new(Table_tablestoreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_tablestore + p.RuleIndex = YQLParserRULE_table_tablestore return p } func InitEmptyTable_tablestoreContext(p *Table_tablestoreContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_tablestore + p.RuleIndex = YQLParserRULE_table_tablestore } func (*Table_tablestoreContext) IsTable_tablestoreContext() {} @@ -50256,7 +50256,7 @@ func NewTable_tablestoreContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_tablestore + p.RuleIndex = YQLParserRULE_table_tablestore return p } @@ -50264,7 +50264,7 @@ func NewTable_tablestoreContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Table_tablestoreContext) GetParser() antlr.Parser { return s.parser } func (s *Table_tablestoreContext) TABLESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESTORE, 0) + return s.GetToken(YQLParserTABLESTORE, 0) } func (s *Table_tablestoreContext) Simple_table_ref_core() ISimple_table_ref_coreContext { @@ -50293,13 +50293,13 @@ func (s *Table_tablestoreContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Table_tablestoreContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_tablestore(s) } } func (s *Table_tablestoreContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_tablestore(s) } } @@ -50307,13 +50307,13 @@ func (s *Table_tablestoreContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_tablestore() (localctx ITable_tablestoreContext) { +func (p *YQLParser) Table_tablestore() (localctx ITable_tablestoreContext) { localctx = NewTable_tablestoreContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 456, YQLv1Antlr4ParserRULE_table_tablestore) + p.EnterRule(localctx, 456, YQLParserRULE_table_tablestore) p.EnterOuterAlt(localctx, 1) { p.SetState(3007) - p.Match(YQLv1Antlr4ParserTABLESTORE) + p.Match(YQLParserTABLESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50364,13 +50364,13 @@ type Table_settings_entryContext struct { func NewEmptyTable_settings_entryContext() *Table_settings_entryContext { var p = new(Table_settings_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_settings_entry + p.RuleIndex = YQLParserRULE_table_settings_entry return p } func InitEmptyTable_settings_entryContext(p *Table_settings_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_settings_entry + p.RuleIndex = YQLParserRULE_table_settings_entry } func (*Table_settings_entryContext) IsTable_settings_entryContext() {} @@ -50381,7 +50381,7 @@ func NewTable_settings_entryContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_settings_entry + p.RuleIndex = YQLParserRULE_table_settings_entry return p } @@ -50405,7 +50405,7 @@ func (s *Table_settings_entryContext) An_id() IAn_idContext { } func (s *Table_settings_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Table_settings_entryContext) Table_setting_value() ITable_setting_valueContext { @@ -50434,13 +50434,13 @@ func (s *Table_settings_entryContext) ToStringTree(ruleNames []string, recog ant func (s *Table_settings_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_settings_entry(s) } } func (s *Table_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_settings_entry(s) } } @@ -50448,9 +50448,9 @@ func (s *Table_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Table_settings_entry() (localctx ITable_settings_entryContext) { +func (p *YQLParser) Table_settings_entry() (localctx ITable_settings_entryContext) { localctx = NewTable_settings_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 458, YQLv1Antlr4ParserRULE_table_settings_entry) + p.EnterRule(localctx, 458, YQLParserRULE_table_settings_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(3010) @@ -50458,7 +50458,7 @@ func (p *YQLv1Antlr4Parser) Table_settings_entry() (localctx ITable_settings_ent } { p.SetState(3011) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50508,13 +50508,13 @@ type Table_as_sourceContext struct { func NewEmptyTable_as_sourceContext() *Table_as_sourceContext { var p = new(Table_as_sourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_as_source + p.RuleIndex = YQLParserRULE_table_as_source return p } func InitEmptyTable_as_sourceContext(p *Table_as_sourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_as_source + p.RuleIndex = YQLParserRULE_table_as_source } func (*Table_as_sourceContext) IsTable_as_sourceContext() {} @@ -50525,7 +50525,7 @@ func NewTable_as_sourceContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_as_source + p.RuleIndex = YQLParserRULE_table_as_source return p } @@ -50533,7 +50533,7 @@ func NewTable_as_sourceContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Table_as_sourceContext) GetParser() antlr.Parser { return s.parser } func (s *Table_as_sourceContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Table_as_sourceContext) Values_source() IValues_sourceContext { @@ -50562,13 +50562,13 @@ func (s *Table_as_sourceContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Table_as_sourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_as_source(s) } } func (s *Table_as_sourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_as_source(s) } } @@ -50576,13 +50576,13 @@ func (s *Table_as_sourceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_as_source() (localctx ITable_as_sourceContext) { +func (p *YQLParser) Table_as_source() (localctx ITable_as_sourceContext) { localctx = NewTable_as_sourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 460, YQLv1Antlr4ParserRULE_table_as_source) + p.EnterRule(localctx, 460, YQLParserRULE_table_as_source) p.EnterOuterAlt(localctx, 1) { p.SetState(3014) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50637,13 +50637,13 @@ type Alter_table_stmtContext struct { func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext { var p = new(Alter_table_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_stmt + p.RuleIndex = YQLParserRULE_alter_table_stmt return p } func InitEmptyAlter_table_stmtContext(p *Alter_table_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_stmt + p.RuleIndex = YQLParserRULE_alter_table_stmt } func (*Alter_table_stmtContext) IsAlter_table_stmtContext() {} @@ -50654,7 +50654,7 @@ func NewAlter_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_stmt + p.RuleIndex = YQLParserRULE_alter_table_stmt return p } @@ -50662,11 +50662,11 @@ func NewAlter_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Alter_table_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_table_stmtContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Alter_table_stmtContext) Simple_table_ref() ISimple_table_refContext { @@ -50727,11 +50727,11 @@ func (s *Alter_table_stmtContext) Alter_table_action(i int) IAlter_table_actionC } func (s *Alter_table_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_table_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_table_stmtContext) GetRuleContext() antlr.RuleContext { @@ -50744,13 +50744,13 @@ func (s *Alter_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Alter_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_stmt(s) } } func (s *Alter_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_stmt(s) } } @@ -50758,15 +50758,15 @@ func (s *Alter_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Alter_table_stmt() (localctx IAlter_table_stmtContext) { +func (p *YQLParser) Alter_table_stmt() (localctx IAlter_table_stmtContext) { localctx = NewAlter_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 462, YQLv1Antlr4ParserRULE_alter_table_stmt) + p.EnterRule(localctx, 462, YQLParserRULE_alter_table_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3017) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50774,7 +50774,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_stmt() (localctx IAlter_table_stmtContex } { p.SetState(3018) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50796,10 +50796,10 @@ func (p *YQLv1Antlr4Parser) Alter_table_stmt() (localctx IAlter_table_stmtContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3021) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50873,13 +50873,13 @@ type Alter_table_actionContext struct { func NewEmptyAlter_table_actionContext() *Alter_table_actionContext { var p = new(Alter_table_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_action + p.RuleIndex = YQLParserRULE_alter_table_action return p } func InitEmptyAlter_table_actionContext(p *Alter_table_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_action + p.RuleIndex = YQLParserRULE_alter_table_action } func (*Alter_table_actionContext) IsAlter_table_actionContext() {} @@ -50890,7 +50890,7 @@ func NewAlter_table_actionContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_action + p.RuleIndex = YQLParserRULE_alter_table_action return p } @@ -51179,13 +51179,13 @@ func (s *Alter_table_actionContext) ToStringTree(ruleNames []string, recog antlr func (s *Alter_table_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_action(s) } } func (s *Alter_table_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_action(s) } } @@ -51193,9 +51193,9 @@ func (s *Alter_table_actionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Alter_table_action() (localctx IAlter_table_actionContext) { +func (p *YQLParser) Alter_table_action() (localctx IAlter_table_actionContext) { localctx = NewAlter_table_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 464, YQLv1Antlr4ParserRULE_alter_table_action) + p.EnterRule(localctx, 464, YQLParserRULE_alter_table_action) p.SetState(3045) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -51386,13 +51386,13 @@ type Alter_external_table_stmtContext struct { func NewEmptyAlter_external_table_stmtContext() *Alter_external_table_stmtContext { var p = new(Alter_external_table_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_table_stmt + p.RuleIndex = YQLParserRULE_alter_external_table_stmt return p } func InitEmptyAlter_external_table_stmtContext(p *Alter_external_table_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_table_stmt + p.RuleIndex = YQLParserRULE_alter_external_table_stmt } func (*Alter_external_table_stmtContext) IsAlter_external_table_stmtContext() {} @@ -51403,7 +51403,7 @@ func NewAlter_external_table_stmtContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_table_stmt + p.RuleIndex = YQLParserRULE_alter_external_table_stmt return p } @@ -51411,15 +51411,15 @@ func NewAlter_external_table_stmtContext(parser antlr.Parser, parent antlr.Parse func (s *Alter_external_table_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_external_table_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_external_table_stmtContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Alter_external_table_stmtContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Alter_external_table_stmtContext) Simple_table_ref() ISimple_table_refContext { @@ -51480,11 +51480,11 @@ func (s *Alter_external_table_stmtContext) Alter_external_table_action(i int) IA } func (s *Alter_external_table_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_external_table_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_external_table_stmtContext) GetRuleContext() antlr.RuleContext { @@ -51497,13 +51497,13 @@ func (s *Alter_external_table_stmtContext) ToStringTree(ruleNames []string, reco func (s *Alter_external_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_external_table_stmt(s) } } func (s *Alter_external_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_external_table_stmt(s) } } @@ -51511,15 +51511,15 @@ func (s *Alter_external_table_stmtContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Alter_external_table_stmt() (localctx IAlter_external_table_stmtContext) { +func (p *YQLParser) Alter_external_table_stmt() (localctx IAlter_external_table_stmtContext) { localctx = NewAlter_external_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 466, YQLv1Antlr4ParserRULE_alter_external_table_stmt) + p.EnterRule(localctx, 466, YQLParserRULE_alter_external_table_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3047) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51527,7 +51527,7 @@ func (p *YQLv1Antlr4Parser) Alter_external_table_stmt() (localctx IAlter_externa } { p.SetState(3048) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51535,7 +51535,7 @@ func (p *YQLv1Antlr4Parser) Alter_external_table_stmt() (localctx IAlter_externa } { p.SetState(3049) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51557,10 +51557,10 @@ func (p *YQLv1Antlr4Parser) Alter_external_table_stmt() (localctx IAlter_externa _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3052) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51622,13 +51622,13 @@ type Alter_external_table_actionContext struct { func NewEmptyAlter_external_table_actionContext() *Alter_external_table_actionContext { var p = new(Alter_external_table_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_table_action + p.RuleIndex = YQLParserRULE_alter_external_table_action return p } func InitEmptyAlter_external_table_actionContext(p *Alter_external_table_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_table_action + p.RuleIndex = YQLParserRULE_alter_external_table_action } func (*Alter_external_table_actionContext) IsAlter_external_table_actionContext() {} @@ -51639,7 +51639,7 @@ func NewAlter_external_table_actionContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_external_table_action + p.RuleIndex = YQLParserRULE_alter_external_table_action return p } @@ -51736,13 +51736,13 @@ func (s *Alter_external_table_actionContext) ToStringTree(ruleNames []string, re func (s *Alter_external_table_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_external_table_action(s) } } func (s *Alter_external_table_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_external_table_action(s) } } @@ -51750,9 +51750,9 @@ func (s *Alter_external_table_actionContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Alter_external_table_action() (localctx IAlter_external_table_actionContext) { +func (p *YQLParser) Alter_external_table_action() (localctx IAlter_external_table_actionContext) { localctx = NewAlter_external_table_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 468, YQLv1Antlr4ParserRULE_alter_external_table_action) + p.EnterRule(localctx, 468, YQLParserRULE_alter_external_table_action) p.SetState(3064) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -51846,13 +51846,13 @@ type Alter_table_store_stmtContext struct { func NewEmptyAlter_table_store_stmtContext() *Alter_table_store_stmtContext { var p = new(Alter_table_store_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_store_stmt + p.RuleIndex = YQLParserRULE_alter_table_store_stmt return p } func InitEmptyAlter_table_store_stmtContext(p *Alter_table_store_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_store_stmt + p.RuleIndex = YQLParserRULE_alter_table_store_stmt } func (*Alter_table_store_stmtContext) IsAlter_table_store_stmtContext() {} @@ -51863,7 +51863,7 @@ func NewAlter_table_store_stmtContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_store_stmt + p.RuleIndex = YQLParserRULE_alter_table_store_stmt return p } @@ -51871,11 +51871,11 @@ func NewAlter_table_store_stmtContext(parser antlr.Parser, parent antlr.ParserRu func (s *Alter_table_store_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_store_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_table_store_stmtContext) TABLESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESTORE, 0) + return s.GetToken(YQLParserTABLESTORE, 0) } func (s *Alter_table_store_stmtContext) Object_ref() IObject_refContext { @@ -51936,11 +51936,11 @@ func (s *Alter_table_store_stmtContext) Alter_table_store_action(i int) IAlter_t } func (s *Alter_table_store_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_table_store_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_table_store_stmtContext) GetRuleContext() antlr.RuleContext { @@ -51953,13 +51953,13 @@ func (s *Alter_table_store_stmtContext) ToStringTree(ruleNames []string, recog a func (s *Alter_table_store_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_store_stmt(s) } } func (s *Alter_table_store_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_store_stmt(s) } } @@ -51967,15 +51967,15 @@ func (s *Alter_table_store_stmtContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Alter_table_store_stmt() (localctx IAlter_table_store_stmtContext) { +func (p *YQLParser) Alter_table_store_stmt() (localctx IAlter_table_store_stmtContext) { localctx = NewAlter_table_store_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 470, YQLv1Antlr4ParserRULE_alter_table_store_stmt) + p.EnterRule(localctx, 470, YQLParserRULE_alter_table_store_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3066) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51983,7 +51983,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_store_stmt() (localctx IAlter_table_stor } { p.SetState(3067) - p.Match(YQLv1Antlr4ParserTABLESTORE) + p.Match(YQLParserTABLESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52005,10 +52005,10 @@ func (p *YQLv1Antlr4Parser) Alter_table_store_stmt() (localctx IAlter_table_stor _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3070) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52067,13 +52067,13 @@ type Alter_table_store_actionContext struct { func NewEmptyAlter_table_store_actionContext() *Alter_table_store_actionContext { var p = new(Alter_table_store_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_store_action + p.RuleIndex = YQLParserRULE_alter_table_store_action return p } func InitEmptyAlter_table_store_actionContext(p *Alter_table_store_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_store_action + p.RuleIndex = YQLParserRULE_alter_table_store_action } func (*Alter_table_store_actionContext) IsAlter_table_store_actionContext() {} @@ -52084,7 +52084,7 @@ func NewAlter_table_store_actionContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_store_action + p.RuleIndex = YQLParserRULE_alter_table_store_action return p } @@ -52133,13 +52133,13 @@ func (s *Alter_table_store_actionContext) ToStringTree(ruleNames []string, recog func (s *Alter_table_store_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_store_action(s) } } func (s *Alter_table_store_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_store_action(s) } } @@ -52147,9 +52147,9 @@ func (s *Alter_table_store_actionContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Alter_table_store_action() (localctx IAlter_table_store_actionContext) { +func (p *YQLParser) Alter_table_store_action() (localctx IAlter_table_store_actionContext) { localctx = NewAlter_table_store_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 472, YQLv1Antlr4ParserRULE_alter_table_store_action) + p.EnterRule(localctx, 472, YQLParserRULE_alter_table_store_action) p.SetState(3079) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -52157,7 +52157,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_store_action() (localctx IAlter_table_st } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserADD: + case YQLParserADD: p.EnterOuterAlt(localctx, 1) { p.SetState(3077) @@ -52165,7 +52165,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_store_action() (localctx IAlter_table_st } - case YQLv1Antlr4ParserDROP: + case YQLParserDROP: p.EnterOuterAlt(localctx, 2) { p.SetState(3078) @@ -52218,13 +52218,13 @@ type Alter_table_add_columnContext struct { func NewEmptyAlter_table_add_columnContext() *Alter_table_add_columnContext { var p = new(Alter_table_add_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_column + p.RuleIndex = YQLParserRULE_alter_table_add_column return p } func InitEmptyAlter_table_add_columnContext(p *Alter_table_add_columnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_column + p.RuleIndex = YQLParserRULE_alter_table_add_column } func (*Alter_table_add_columnContext) IsAlter_table_add_columnContext() {} @@ -52235,7 +52235,7 @@ func NewAlter_table_add_columnContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_column + p.RuleIndex = YQLParserRULE_alter_table_add_column return p } @@ -52243,7 +52243,7 @@ func NewAlter_table_add_columnContext(parser antlr.Parser, parent antlr.ParserRu func (s *Alter_table_add_columnContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_add_columnContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Alter_table_add_columnContext) Column_schema() IColumn_schemaContext { @@ -52263,7 +52263,7 @@ func (s *Alter_table_add_columnContext) Column_schema() IColumn_schemaContext { } func (s *Alter_table_add_columnContext) COLUMN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMN, 0) + return s.GetToken(YQLParserCOLUMN, 0) } func (s *Alter_table_add_columnContext) GetRuleContext() antlr.RuleContext { @@ -52276,13 +52276,13 @@ func (s *Alter_table_add_columnContext) ToStringTree(ruleNames []string, recog a func (s *Alter_table_add_columnContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_add_column(s) } } func (s *Alter_table_add_columnContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_add_column(s) } } @@ -52290,15 +52290,15 @@ func (s *Alter_table_add_columnContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Alter_table_add_column() (localctx IAlter_table_add_columnContext) { +func (p *YQLParser) Alter_table_add_column() (localctx IAlter_table_add_columnContext) { localctx = NewAlter_table_add_columnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 474, YQLv1Antlr4ParserRULE_alter_table_add_column) + p.EnterRule(localctx, 474, YQLParserRULE_alter_table_add_column) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3081) - p.Match(YQLv1Antlr4ParserADD) + p.Match(YQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52312,10 +52312,10 @@ func (p *YQLv1Antlr4Parser) Alter_table_add_column() (localctx IAlter_table_add_ _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOLUMN { + if _la == YQLParserCOLUMN { { p.SetState(3082) - p.Match(YQLv1Antlr4ParserCOLUMN) + p.Match(YQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52368,13 +52368,13 @@ type Alter_table_drop_columnContext struct { func NewEmptyAlter_table_drop_columnContext() *Alter_table_drop_columnContext { var p = new(Alter_table_drop_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_column + p.RuleIndex = YQLParserRULE_alter_table_drop_column return p } func InitEmptyAlter_table_drop_columnContext(p *Alter_table_drop_columnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_column + p.RuleIndex = YQLParserRULE_alter_table_drop_column } func (*Alter_table_drop_columnContext) IsAlter_table_drop_columnContext() {} @@ -52385,7 +52385,7 @@ func NewAlter_table_drop_columnContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_column + p.RuleIndex = YQLParserRULE_alter_table_drop_column return p } @@ -52393,7 +52393,7 @@ func NewAlter_table_drop_columnContext(parser antlr.Parser, parent antlr.ParserR func (s *Alter_table_drop_columnContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_drop_columnContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Alter_table_drop_columnContext) An_id() IAn_idContext { @@ -52413,7 +52413,7 @@ func (s *Alter_table_drop_columnContext) An_id() IAn_idContext { } func (s *Alter_table_drop_columnContext) COLUMN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMN, 0) + return s.GetToken(YQLParserCOLUMN, 0) } func (s *Alter_table_drop_columnContext) GetRuleContext() antlr.RuleContext { @@ -52426,13 +52426,13 @@ func (s *Alter_table_drop_columnContext) ToStringTree(ruleNames []string, recog func (s *Alter_table_drop_columnContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_drop_column(s) } } func (s *Alter_table_drop_columnContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_drop_column(s) } } @@ -52440,13 +52440,13 @@ func (s *Alter_table_drop_columnContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Alter_table_drop_column() (localctx IAlter_table_drop_columnContext) { +func (p *YQLParser) Alter_table_drop_column() (localctx IAlter_table_drop_columnContext) { localctx = NewAlter_table_drop_columnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 476, YQLv1Antlr4ParserRULE_alter_table_drop_column) + p.EnterRule(localctx, 476, YQLParserRULE_alter_table_drop_column) p.EnterOuterAlt(localctx, 1) { p.SetState(3087) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52459,7 +52459,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_drop_column() (localctx IAlter_table_dro if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 307, p.GetParserRuleContext()) == 1 { { p.SetState(3088) - p.Match(YQLv1Antlr4ParserCOLUMN) + p.Match(YQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52516,13 +52516,13 @@ type Alter_table_alter_columnContext struct { func NewEmptyAlter_table_alter_columnContext() *Alter_table_alter_columnContext { var p = new(Alter_table_alter_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column + p.RuleIndex = YQLParserRULE_alter_table_alter_column return p } func InitEmptyAlter_table_alter_columnContext(p *Alter_table_alter_columnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column + p.RuleIndex = YQLParserRULE_alter_table_alter_column } func (*Alter_table_alter_columnContext) IsAlter_table_alter_columnContext() {} @@ -52533,7 +52533,7 @@ func NewAlter_table_alter_columnContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column + p.RuleIndex = YQLParserRULE_alter_table_alter_column return p } @@ -52541,11 +52541,11 @@ func NewAlter_table_alter_columnContext(parser antlr.Parser, parent antlr.Parser func (s *Alter_table_alter_columnContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_alter_columnContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_table_alter_columnContext) COLUMN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMN, 0) + return s.GetToken(YQLParserCOLUMN, 0) } func (s *Alter_table_alter_columnContext) An_id() IAn_idContext { @@ -52565,7 +52565,7 @@ func (s *Alter_table_alter_columnContext) An_id() IAn_idContext { } func (s *Alter_table_alter_columnContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Alter_table_alter_columnContext) Family_relation() IFamily_relationContext { @@ -52594,13 +52594,13 @@ func (s *Alter_table_alter_columnContext) ToStringTree(ruleNames []string, recog func (s *Alter_table_alter_columnContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_alter_column(s) } } func (s *Alter_table_alter_columnContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_alter_column(s) } } @@ -52608,13 +52608,13 @@ func (s *Alter_table_alter_columnContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Alter_table_alter_column() (localctx IAlter_table_alter_columnContext) { +func (p *YQLParser) Alter_table_alter_column() (localctx IAlter_table_alter_columnContext) { localctx = NewAlter_table_alter_columnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 478, YQLv1Antlr4ParserRULE_alter_table_alter_column) + p.EnterRule(localctx, 478, YQLParserRULE_alter_table_alter_column) p.EnterOuterAlt(localctx, 1) { p.SetState(3093) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52622,7 +52622,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column() (localctx IAlter_table_al } { p.SetState(3094) - p.Match(YQLv1Antlr4ParserCOLUMN) + p.Match(YQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52634,7 +52634,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column() (localctx IAlter_table_al } { p.SetState(3096) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52688,13 +52688,13 @@ type Alter_table_alter_column_drop_not_nullContext struct { func NewEmptyAlter_table_alter_column_drop_not_nullContext() *Alter_table_alter_column_drop_not_nullContext { var p = new(Alter_table_alter_column_drop_not_nullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column_drop_not_null + p.RuleIndex = YQLParserRULE_alter_table_alter_column_drop_not_null return p } func InitEmptyAlter_table_alter_column_drop_not_nullContext(p *Alter_table_alter_column_drop_not_nullContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column_drop_not_null + p.RuleIndex = YQLParserRULE_alter_table_alter_column_drop_not_null } func (*Alter_table_alter_column_drop_not_nullContext) IsAlter_table_alter_column_drop_not_nullContext() {} @@ -52705,7 +52705,7 @@ func NewAlter_table_alter_column_drop_not_nullContext(parser antlr.Parser, paren antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column_drop_not_null + p.RuleIndex = YQLParserRULE_alter_table_alter_column_drop_not_null return p } @@ -52713,11 +52713,11 @@ func NewAlter_table_alter_column_drop_not_nullContext(parser antlr.Parser, paren func (s *Alter_table_alter_column_drop_not_nullContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_alter_column_drop_not_nullContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_table_alter_column_drop_not_nullContext) COLUMN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMN, 0) + return s.GetToken(YQLParserCOLUMN, 0) } func (s *Alter_table_alter_column_drop_not_nullContext) An_id() IAn_idContext { @@ -52737,15 +52737,15 @@ func (s *Alter_table_alter_column_drop_not_nullContext) An_id() IAn_idContext { } func (s *Alter_table_alter_column_drop_not_nullContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Alter_table_alter_column_drop_not_nullContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Alter_table_alter_column_drop_not_nullContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Alter_table_alter_column_drop_not_nullContext) GetRuleContext() antlr.RuleContext { @@ -52758,13 +52758,13 @@ func (s *Alter_table_alter_column_drop_not_nullContext) ToStringTree(ruleNames [ func (s *Alter_table_alter_column_drop_not_nullContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_alter_column_drop_not_null(s) } } func (s *Alter_table_alter_column_drop_not_nullContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_alter_column_drop_not_null(s) } } @@ -52772,13 +52772,13 @@ func (s *Alter_table_alter_column_drop_not_nullContext) ExitRule(listener antlr. -func (p *YQLv1Antlr4Parser) Alter_table_alter_column_drop_not_null() (localctx IAlter_table_alter_column_drop_not_nullContext) { +func (p *YQLParser) Alter_table_alter_column_drop_not_null() (localctx IAlter_table_alter_column_drop_not_nullContext) { localctx = NewAlter_table_alter_column_drop_not_nullContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 480, YQLv1Antlr4ParserRULE_alter_table_alter_column_drop_not_null) + p.EnterRule(localctx, 480, YQLParserRULE_alter_table_alter_column_drop_not_null) p.EnterOuterAlt(localctx, 1) { p.SetState(3099) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52786,7 +52786,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column_drop_not_null() (localctx I } { p.SetState(3100) - p.Match(YQLv1Antlr4ParserCOLUMN) + p.Match(YQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52798,7 +52798,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column_drop_not_null() (localctx I } { p.SetState(3102) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52806,7 +52806,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column_drop_not_null() (localctx I } { p.SetState(3103) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52814,7 +52814,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column_drop_not_null() (localctx I } { p.SetState(3104) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52860,13 +52860,13 @@ type Alter_table_add_column_familyContext struct { func NewEmptyAlter_table_add_column_familyContext() *Alter_table_add_column_familyContext { var p = new(Alter_table_add_column_familyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_column_family + p.RuleIndex = YQLParserRULE_alter_table_add_column_family return p } func InitEmptyAlter_table_add_column_familyContext(p *Alter_table_add_column_familyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_column_family + p.RuleIndex = YQLParserRULE_alter_table_add_column_family } func (*Alter_table_add_column_familyContext) IsAlter_table_add_column_familyContext() {} @@ -52877,7 +52877,7 @@ func NewAlter_table_add_column_familyContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_column_family + p.RuleIndex = YQLParserRULE_alter_table_add_column_family return p } @@ -52885,7 +52885,7 @@ func NewAlter_table_add_column_familyContext(parser antlr.Parser, parent antlr.P func (s *Alter_table_add_column_familyContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_add_column_familyContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Alter_table_add_column_familyContext) Family_entry() IFamily_entryContext { @@ -52914,13 +52914,13 @@ func (s *Alter_table_add_column_familyContext) ToStringTree(ruleNames []string, func (s *Alter_table_add_column_familyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_add_column_family(s) } } func (s *Alter_table_add_column_familyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_add_column_family(s) } } @@ -52928,13 +52928,13 @@ func (s *Alter_table_add_column_familyContext) ExitRule(listener antlr.ParseTree -func (p *YQLv1Antlr4Parser) Alter_table_add_column_family() (localctx IAlter_table_add_column_familyContext) { +func (p *YQLParser) Alter_table_add_column_family() (localctx IAlter_table_add_column_familyContext) { localctx = NewAlter_table_add_column_familyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 482, YQLv1Antlr4ParserRULE_alter_table_add_column_family) + p.EnterRule(localctx, 482, YQLParserRULE_alter_table_add_column_family) p.EnterOuterAlt(localctx, 1) { p.SetState(3106) - p.Match(YQLv1Antlr4ParserADD) + p.Match(YQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52988,13 +52988,13 @@ type Alter_table_alter_column_familyContext struct { func NewEmptyAlter_table_alter_column_familyContext() *Alter_table_alter_column_familyContext { var p = new(Alter_table_alter_column_familyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column_family + p.RuleIndex = YQLParserRULE_alter_table_alter_column_family return p } func InitEmptyAlter_table_alter_column_familyContext(p *Alter_table_alter_column_familyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column_family + p.RuleIndex = YQLParserRULE_alter_table_alter_column_family } func (*Alter_table_alter_column_familyContext) IsAlter_table_alter_column_familyContext() {} @@ -53005,7 +53005,7 @@ func NewAlter_table_alter_column_familyContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_column_family + p.RuleIndex = YQLParserRULE_alter_table_alter_column_family return p } @@ -53013,11 +53013,11 @@ func NewAlter_table_alter_column_familyContext(parser antlr.Parser, parent antlr func (s *Alter_table_alter_column_familyContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_alter_column_familyContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_table_alter_column_familyContext) FAMILY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFAMILY, 0) + return s.GetToken(YQLParserFAMILY, 0) } func (s *Alter_table_alter_column_familyContext) AllAn_id() []IAn_idContext { @@ -53062,7 +53062,7 @@ func (s *Alter_table_alter_column_familyContext) An_id(i int) IAn_idContext { } func (s *Alter_table_alter_column_familyContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Alter_table_alter_column_familyContext) Family_setting_value() IFamily_setting_valueContext { @@ -53091,13 +53091,13 @@ func (s *Alter_table_alter_column_familyContext) ToStringTree(ruleNames []string func (s *Alter_table_alter_column_familyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_alter_column_family(s) } } func (s *Alter_table_alter_column_familyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_alter_column_family(s) } } @@ -53105,13 +53105,13 @@ func (s *Alter_table_alter_column_familyContext) ExitRule(listener antlr.ParseTr -func (p *YQLv1Antlr4Parser) Alter_table_alter_column_family() (localctx IAlter_table_alter_column_familyContext) { +func (p *YQLParser) Alter_table_alter_column_family() (localctx IAlter_table_alter_column_familyContext) { localctx = NewAlter_table_alter_column_familyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 484, YQLv1Antlr4ParserRULE_alter_table_alter_column_family) + p.EnterRule(localctx, 484, YQLParserRULE_alter_table_alter_column_family) p.EnterOuterAlt(localctx, 1) { p.SetState(3109) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53119,7 +53119,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column_family() (localctx IAlter_t } { p.SetState(3110) - p.Match(YQLv1Antlr4ParserFAMILY) + p.Match(YQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53131,7 +53131,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_column_family() (localctx IAlter_t } { p.SetState(3112) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53186,13 +53186,13 @@ type Alter_table_set_table_setting_uncompatContext struct { func NewEmptyAlter_table_set_table_setting_uncompatContext() *Alter_table_set_table_setting_uncompatContext { var p = new(Alter_table_set_table_setting_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_set_table_setting_uncompat + p.RuleIndex = YQLParserRULE_alter_table_set_table_setting_uncompat return p } func InitEmptyAlter_table_set_table_setting_uncompatContext(p *Alter_table_set_table_setting_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_set_table_setting_uncompat + p.RuleIndex = YQLParserRULE_alter_table_set_table_setting_uncompat } func (*Alter_table_set_table_setting_uncompatContext) IsAlter_table_set_table_setting_uncompatContext() {} @@ -53203,7 +53203,7 @@ func NewAlter_table_set_table_setting_uncompatContext(parser antlr.Parser, paren antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_set_table_setting_uncompat + p.RuleIndex = YQLParserRULE_alter_table_set_table_setting_uncompat return p } @@ -53211,7 +53211,7 @@ func NewAlter_table_set_table_setting_uncompatContext(parser antlr.Parser, paren func (s *Alter_table_set_table_setting_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_set_table_setting_uncompatContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Alter_table_set_table_setting_uncompatContext) An_id() IAn_idContext { @@ -53256,13 +53256,13 @@ func (s *Alter_table_set_table_setting_uncompatContext) ToStringTree(ruleNames [ func (s *Alter_table_set_table_setting_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_set_table_setting_uncompat(s) } } func (s *Alter_table_set_table_setting_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_set_table_setting_uncompat(s) } } @@ -53270,13 +53270,13 @@ func (s *Alter_table_set_table_setting_uncompatContext) ExitRule(listener antlr. -func (p *YQLv1Antlr4Parser) Alter_table_set_table_setting_uncompat() (localctx IAlter_table_set_table_setting_uncompatContext) { +func (p *YQLParser) Alter_table_set_table_setting_uncompat() (localctx IAlter_table_set_table_setting_uncompatContext) { localctx = NewAlter_table_set_table_setting_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 486, YQLv1Antlr4ParserRULE_alter_table_set_table_setting_uncompat) + p.EnterRule(localctx, 486, YQLParserRULE_alter_table_set_table_setting_uncompat) p.EnterOuterAlt(localctx, 1) { p.SetState(3116) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53335,13 +53335,13 @@ type Alter_table_set_table_setting_compatContext struct { func NewEmptyAlter_table_set_table_setting_compatContext() *Alter_table_set_table_setting_compatContext { var p = new(Alter_table_set_table_setting_compatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_set_table_setting_compat + p.RuleIndex = YQLParserRULE_alter_table_set_table_setting_compat return p } func InitEmptyAlter_table_set_table_setting_compatContext(p *Alter_table_set_table_setting_compatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_set_table_setting_compat + p.RuleIndex = YQLParserRULE_alter_table_set_table_setting_compat } func (*Alter_table_set_table_setting_compatContext) IsAlter_table_set_table_setting_compatContext() {} @@ -53352,7 +53352,7 @@ func NewAlter_table_set_table_setting_compatContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_set_table_setting_compat + p.RuleIndex = YQLParserRULE_alter_table_set_table_setting_compat return p } @@ -53360,11 +53360,11 @@ func NewAlter_table_set_table_setting_compatContext(parser antlr.Parser, parent func (s *Alter_table_set_table_setting_compatContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_set_table_setting_compatContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Alter_table_set_table_setting_compatContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Alter_table_set_table_setting_compatContext) AllAlter_table_setting_entry() []IAlter_table_setting_entryContext { @@ -53409,15 +53409,15 @@ func (s *Alter_table_set_table_setting_compatContext) Alter_table_setting_entry( } func (s *Alter_table_set_table_setting_compatContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Alter_table_set_table_setting_compatContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_table_set_table_setting_compatContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_table_set_table_setting_compatContext) GetRuleContext() antlr.RuleContext { @@ -53430,13 +53430,13 @@ func (s *Alter_table_set_table_setting_compatContext) ToStringTree(ruleNames []s func (s *Alter_table_set_table_setting_compatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_set_table_setting_compat(s) } } func (s *Alter_table_set_table_setting_compatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_set_table_setting_compat(s) } } @@ -53444,15 +53444,15 @@ func (s *Alter_table_set_table_setting_compatContext) ExitRule(listener antlr.Pa -func (p *YQLv1Antlr4Parser) Alter_table_set_table_setting_compat() (localctx IAlter_table_set_table_setting_compatContext) { +func (p *YQLParser) Alter_table_set_table_setting_compat() (localctx IAlter_table_set_table_setting_compatContext) { localctx = NewAlter_table_set_table_setting_compatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 488, YQLv1Antlr4ParserRULE_alter_table_set_table_setting_compat) + p.EnterRule(localctx, 488, YQLParserRULE_alter_table_set_table_setting_compat) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3120) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53460,7 +53460,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_set_table_setting_compat() (localctx IAl } { p.SetState(3121) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53478,10 +53478,10 @@ func (p *YQLv1Antlr4Parser) Alter_table_set_table_setting_compat() (localctx IAl _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3123) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53502,7 +53502,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_set_table_setting_compat() (localctx IAl } { p.SetState(3130) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53553,13 +53553,13 @@ type Alter_table_reset_table_settingContext struct { func NewEmptyAlter_table_reset_table_settingContext() *Alter_table_reset_table_settingContext { var p = new(Alter_table_reset_table_settingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_reset_table_setting + p.RuleIndex = YQLParserRULE_alter_table_reset_table_setting return p } func InitEmptyAlter_table_reset_table_settingContext(p *Alter_table_reset_table_settingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_reset_table_setting + p.RuleIndex = YQLParserRULE_alter_table_reset_table_setting } func (*Alter_table_reset_table_settingContext) IsAlter_table_reset_table_settingContext() {} @@ -53570,7 +53570,7 @@ func NewAlter_table_reset_table_settingContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_reset_table_setting + p.RuleIndex = YQLParserRULE_alter_table_reset_table_setting return p } @@ -53578,11 +53578,11 @@ func NewAlter_table_reset_table_settingContext(parser antlr.Parser, parent antlr func (s *Alter_table_reset_table_settingContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_reset_table_settingContext) RESET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESET, 0) + return s.GetToken(YQLParserRESET, 0) } func (s *Alter_table_reset_table_settingContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Alter_table_reset_table_settingContext) AllAn_id() []IAn_idContext { @@ -53627,15 +53627,15 @@ func (s *Alter_table_reset_table_settingContext) An_id(i int) IAn_idContext { } func (s *Alter_table_reset_table_settingContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Alter_table_reset_table_settingContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_table_reset_table_settingContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_table_reset_table_settingContext) GetRuleContext() antlr.RuleContext { @@ -53648,13 +53648,13 @@ func (s *Alter_table_reset_table_settingContext) ToStringTree(ruleNames []string func (s *Alter_table_reset_table_settingContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_reset_table_setting(s) } } func (s *Alter_table_reset_table_settingContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_reset_table_setting(s) } } @@ -53662,15 +53662,15 @@ func (s *Alter_table_reset_table_settingContext) ExitRule(listener antlr.ParseTr -func (p *YQLv1Antlr4Parser) Alter_table_reset_table_setting() (localctx IAlter_table_reset_table_settingContext) { +func (p *YQLParser) Alter_table_reset_table_setting() (localctx IAlter_table_reset_table_settingContext) { localctx = NewAlter_table_reset_table_settingContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 490, YQLv1Antlr4ParserRULE_alter_table_reset_table_setting) + p.EnterRule(localctx, 490, YQLParserRULE_alter_table_reset_table_setting) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3132) - p.Match(YQLv1Antlr4ParserRESET) + p.Match(YQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53678,7 +53678,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_reset_table_setting() (localctx IAlter_t } { p.SetState(3133) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53696,10 +53696,10 @@ func (p *YQLv1Antlr4Parser) Alter_table_reset_table_setting() (localctx IAlter_t _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3135) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53720,7 +53720,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_reset_table_setting() (localctx IAlter_t } { p.SetState(3142) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53766,13 +53766,13 @@ type Alter_table_add_indexContext struct { func NewEmptyAlter_table_add_indexContext() *Alter_table_add_indexContext { var p = new(Alter_table_add_indexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_index + p.RuleIndex = YQLParserRULE_alter_table_add_index return p } func InitEmptyAlter_table_add_indexContext(p *Alter_table_add_indexContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_index + p.RuleIndex = YQLParserRULE_alter_table_add_index } func (*Alter_table_add_indexContext) IsAlter_table_add_indexContext() {} @@ -53783,7 +53783,7 @@ func NewAlter_table_add_indexContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_index + p.RuleIndex = YQLParserRULE_alter_table_add_index return p } @@ -53791,7 +53791,7 @@ func NewAlter_table_add_indexContext(parser antlr.Parser, parent antlr.ParserRul func (s *Alter_table_add_indexContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_add_indexContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Alter_table_add_indexContext) Table_index() ITable_indexContext { @@ -53820,13 +53820,13 @@ func (s *Alter_table_add_indexContext) ToStringTree(ruleNames []string, recog an func (s *Alter_table_add_indexContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_add_index(s) } } func (s *Alter_table_add_indexContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_add_index(s) } } @@ -53834,13 +53834,13 @@ func (s *Alter_table_add_indexContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Alter_table_add_index() (localctx IAlter_table_add_indexContext) { +func (p *YQLParser) Alter_table_add_index() (localctx IAlter_table_add_indexContext) { localctx = NewAlter_table_add_indexContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 492, YQLv1Antlr4ParserRULE_alter_table_add_index) + p.EnterRule(localctx, 492, YQLParserRULE_alter_table_add_index) p.EnterOuterAlt(localctx, 1) { p.SetState(3144) - p.Match(YQLv1Antlr4ParserADD) + p.Match(YQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53891,13 +53891,13 @@ type Alter_table_drop_indexContext struct { func NewEmptyAlter_table_drop_indexContext() *Alter_table_drop_indexContext { var p = new(Alter_table_drop_indexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_index + p.RuleIndex = YQLParserRULE_alter_table_drop_index return p } func InitEmptyAlter_table_drop_indexContext(p *Alter_table_drop_indexContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_index + p.RuleIndex = YQLParserRULE_alter_table_drop_index } func (*Alter_table_drop_indexContext) IsAlter_table_drop_indexContext() {} @@ -53908,7 +53908,7 @@ func NewAlter_table_drop_indexContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_index + p.RuleIndex = YQLParserRULE_alter_table_drop_index return p } @@ -53916,11 +53916,11 @@ func NewAlter_table_drop_indexContext(parser antlr.Parser, parent antlr.ParserRu func (s *Alter_table_drop_indexContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_drop_indexContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Alter_table_drop_indexContext) INDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEX, 0) + return s.GetToken(YQLParserINDEX, 0) } func (s *Alter_table_drop_indexContext) An_id() IAn_idContext { @@ -53949,13 +53949,13 @@ func (s *Alter_table_drop_indexContext) ToStringTree(ruleNames []string, recog a func (s *Alter_table_drop_indexContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_drop_index(s) } } func (s *Alter_table_drop_indexContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_drop_index(s) } } @@ -53963,13 +53963,13 @@ func (s *Alter_table_drop_indexContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Alter_table_drop_index() (localctx IAlter_table_drop_indexContext) { +func (p *YQLParser) Alter_table_drop_index() (localctx IAlter_table_drop_indexContext) { localctx = NewAlter_table_drop_indexContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 494, YQLv1Antlr4ParserRULE_alter_table_drop_index) + p.EnterRule(localctx, 494, YQLParserRULE_alter_table_drop_index) p.EnterOuterAlt(localctx, 1) { p.SetState(3147) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53977,7 +53977,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_drop_index() (localctx IAlter_table_drop } { p.SetState(3148) - p.Match(YQLv1Antlr4ParserINDEX) + p.Match(YQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54028,13 +54028,13 @@ type Alter_table_rename_toContext struct { func NewEmptyAlter_table_rename_toContext() *Alter_table_rename_toContext { var p = new(Alter_table_rename_toContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_rename_to + p.RuleIndex = YQLParserRULE_alter_table_rename_to return p } func InitEmptyAlter_table_rename_toContext(p *Alter_table_rename_toContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_rename_to + p.RuleIndex = YQLParserRULE_alter_table_rename_to } func (*Alter_table_rename_toContext) IsAlter_table_rename_toContext() {} @@ -54045,7 +54045,7 @@ func NewAlter_table_rename_toContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_rename_to + p.RuleIndex = YQLParserRULE_alter_table_rename_to return p } @@ -54053,11 +54053,11 @@ func NewAlter_table_rename_toContext(parser antlr.Parser, parent antlr.ParserRul func (s *Alter_table_rename_toContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_rename_toContext) RENAME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRENAME, 0) + return s.GetToken(YQLParserRENAME, 0) } func (s *Alter_table_rename_toContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Alter_table_rename_toContext) An_id_table() IAn_id_tableContext { @@ -54086,13 +54086,13 @@ func (s *Alter_table_rename_toContext) ToStringTree(ruleNames []string, recog an func (s *Alter_table_rename_toContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_rename_to(s) } } func (s *Alter_table_rename_toContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_rename_to(s) } } @@ -54100,13 +54100,13 @@ func (s *Alter_table_rename_toContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Alter_table_rename_to() (localctx IAlter_table_rename_toContext) { +func (p *YQLParser) Alter_table_rename_to() (localctx IAlter_table_rename_toContext) { localctx = NewAlter_table_rename_toContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 496, YQLv1Antlr4ParserRULE_alter_table_rename_to) + p.EnterRule(localctx, 496, YQLParserRULE_alter_table_rename_to) p.EnterOuterAlt(localctx, 1) { p.SetState(3151) - p.Match(YQLv1Antlr4ParserRENAME) + p.Match(YQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54114,7 +54114,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_rename_to() (localctx IAlter_table_renam } { p.SetState(3152) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54167,13 +54167,13 @@ type Alter_table_rename_index_toContext struct { func NewEmptyAlter_table_rename_index_toContext() *Alter_table_rename_index_toContext { var p = new(Alter_table_rename_index_toContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_rename_index_to + p.RuleIndex = YQLParserRULE_alter_table_rename_index_to return p } func InitEmptyAlter_table_rename_index_toContext(p *Alter_table_rename_index_toContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_rename_index_to + p.RuleIndex = YQLParserRULE_alter_table_rename_index_to } func (*Alter_table_rename_index_toContext) IsAlter_table_rename_index_toContext() {} @@ -54184,7 +54184,7 @@ func NewAlter_table_rename_index_toContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_rename_index_to + p.RuleIndex = YQLParserRULE_alter_table_rename_index_to return p } @@ -54192,11 +54192,11 @@ func NewAlter_table_rename_index_toContext(parser antlr.Parser, parent antlr.Par func (s *Alter_table_rename_index_toContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_rename_index_toContext) RENAME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRENAME, 0) + return s.GetToken(YQLParserRENAME, 0) } func (s *Alter_table_rename_index_toContext) INDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEX, 0) + return s.GetToken(YQLParserINDEX, 0) } func (s *Alter_table_rename_index_toContext) AllAn_id() []IAn_idContext { @@ -54241,7 +54241,7 @@ func (s *Alter_table_rename_index_toContext) An_id(i int) IAn_idContext { } func (s *Alter_table_rename_index_toContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Alter_table_rename_index_toContext) GetRuleContext() antlr.RuleContext { @@ -54254,13 +54254,13 @@ func (s *Alter_table_rename_index_toContext) ToStringTree(ruleNames []string, re func (s *Alter_table_rename_index_toContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_rename_index_to(s) } } func (s *Alter_table_rename_index_toContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_rename_index_to(s) } } @@ -54268,13 +54268,13 @@ func (s *Alter_table_rename_index_toContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Alter_table_rename_index_to() (localctx IAlter_table_rename_index_toContext) { +func (p *YQLParser) Alter_table_rename_index_to() (localctx IAlter_table_rename_index_toContext) { localctx = NewAlter_table_rename_index_toContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 498, YQLv1Antlr4ParserRULE_alter_table_rename_index_to) + p.EnterRule(localctx, 498, YQLParserRULE_alter_table_rename_index_to) p.EnterOuterAlt(localctx, 1) { p.SetState(3155) - p.Match(YQLv1Antlr4ParserRENAME) + p.Match(YQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54282,7 +54282,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_rename_index_to() (localctx IAlter_table } { p.SetState(3156) - p.Match(YQLv1Antlr4ParserINDEX) + p.Match(YQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54294,7 +54294,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_rename_index_to() (localctx IAlter_table } { p.SetState(3158) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54344,13 +54344,13 @@ type Alter_table_add_changefeedContext struct { func NewEmptyAlter_table_add_changefeedContext() *Alter_table_add_changefeedContext { var p = new(Alter_table_add_changefeedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_changefeed + p.RuleIndex = YQLParserRULE_alter_table_add_changefeed return p } func InitEmptyAlter_table_add_changefeedContext(p *Alter_table_add_changefeedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_changefeed + p.RuleIndex = YQLParserRULE_alter_table_add_changefeed } func (*Alter_table_add_changefeedContext) IsAlter_table_add_changefeedContext() {} @@ -54361,7 +54361,7 @@ func NewAlter_table_add_changefeedContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_add_changefeed + p.RuleIndex = YQLParserRULE_alter_table_add_changefeed return p } @@ -54369,7 +54369,7 @@ func NewAlter_table_add_changefeedContext(parser antlr.Parser, parent antlr.Pars func (s *Alter_table_add_changefeedContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_add_changefeedContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Alter_table_add_changefeedContext) Changefeed() IChangefeedContext { @@ -54398,13 +54398,13 @@ func (s *Alter_table_add_changefeedContext) ToStringTree(ruleNames []string, rec func (s *Alter_table_add_changefeedContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_add_changefeed(s) } } func (s *Alter_table_add_changefeedContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_add_changefeed(s) } } @@ -54412,13 +54412,13 @@ func (s *Alter_table_add_changefeedContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Alter_table_add_changefeed() (localctx IAlter_table_add_changefeedContext) { +func (p *YQLParser) Alter_table_add_changefeed() (localctx IAlter_table_add_changefeedContext) { localctx = NewAlter_table_add_changefeedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 500, YQLv1Antlr4ParserRULE_alter_table_add_changefeed) + p.EnterRule(localctx, 500, YQLParserRULE_alter_table_add_changefeed) p.EnterOuterAlt(localctx, 1) { p.SetState(3161) - p.Match(YQLv1Antlr4ParserADD) + p.Match(YQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54470,13 +54470,13 @@ type Alter_table_alter_changefeedContext struct { func NewEmptyAlter_table_alter_changefeedContext() *Alter_table_alter_changefeedContext { var p = new(Alter_table_alter_changefeedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_changefeed + p.RuleIndex = YQLParserRULE_alter_table_alter_changefeed return p } func InitEmptyAlter_table_alter_changefeedContext(p *Alter_table_alter_changefeedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_changefeed + p.RuleIndex = YQLParserRULE_alter_table_alter_changefeed } func (*Alter_table_alter_changefeedContext) IsAlter_table_alter_changefeedContext() {} @@ -54487,7 +54487,7 @@ func NewAlter_table_alter_changefeedContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_changefeed + p.RuleIndex = YQLParserRULE_alter_table_alter_changefeed return p } @@ -54495,11 +54495,11 @@ func NewAlter_table_alter_changefeedContext(parser antlr.Parser, parent antlr.Pa func (s *Alter_table_alter_changefeedContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_alter_changefeedContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_table_alter_changefeedContext) CHANGEFEED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCHANGEFEED, 0) + return s.GetToken(YQLParserCHANGEFEED, 0) } func (s *Alter_table_alter_changefeedContext) An_id() IAn_idContext { @@ -54544,13 +54544,13 @@ func (s *Alter_table_alter_changefeedContext) ToStringTree(ruleNames []string, r func (s *Alter_table_alter_changefeedContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_alter_changefeed(s) } } func (s *Alter_table_alter_changefeedContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_alter_changefeed(s) } } @@ -54558,13 +54558,13 @@ func (s *Alter_table_alter_changefeedContext) ExitRule(listener antlr.ParseTreeL -func (p *YQLv1Antlr4Parser) Alter_table_alter_changefeed() (localctx IAlter_table_alter_changefeedContext) { +func (p *YQLParser) Alter_table_alter_changefeed() (localctx IAlter_table_alter_changefeedContext) { localctx = NewAlter_table_alter_changefeedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 502, YQLv1Antlr4ParserRULE_alter_table_alter_changefeed) + p.EnterRule(localctx, 502, YQLParserRULE_alter_table_alter_changefeed) p.EnterOuterAlt(localctx, 1) { p.SetState(3164) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54572,7 +54572,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_changefeed() (localctx IAlter_tabl } { p.SetState(3165) - p.Match(YQLv1Antlr4ParserCHANGEFEED) + p.Match(YQLParserCHANGEFEED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54627,13 +54627,13 @@ type Alter_table_drop_changefeedContext struct { func NewEmptyAlter_table_drop_changefeedContext() *Alter_table_drop_changefeedContext { var p = new(Alter_table_drop_changefeedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_changefeed + p.RuleIndex = YQLParserRULE_alter_table_drop_changefeed return p } func InitEmptyAlter_table_drop_changefeedContext(p *Alter_table_drop_changefeedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_changefeed + p.RuleIndex = YQLParserRULE_alter_table_drop_changefeed } func (*Alter_table_drop_changefeedContext) IsAlter_table_drop_changefeedContext() {} @@ -54644,7 +54644,7 @@ func NewAlter_table_drop_changefeedContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_drop_changefeed + p.RuleIndex = YQLParserRULE_alter_table_drop_changefeed return p } @@ -54652,11 +54652,11 @@ func NewAlter_table_drop_changefeedContext(parser antlr.Parser, parent antlr.Par func (s *Alter_table_drop_changefeedContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_drop_changefeedContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Alter_table_drop_changefeedContext) CHANGEFEED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCHANGEFEED, 0) + return s.GetToken(YQLParserCHANGEFEED, 0) } func (s *Alter_table_drop_changefeedContext) An_id() IAn_idContext { @@ -54685,13 +54685,13 @@ func (s *Alter_table_drop_changefeedContext) ToStringTree(ruleNames []string, re func (s *Alter_table_drop_changefeedContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_drop_changefeed(s) } } func (s *Alter_table_drop_changefeedContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_drop_changefeed(s) } } @@ -54699,13 +54699,13 @@ func (s *Alter_table_drop_changefeedContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Alter_table_drop_changefeed() (localctx IAlter_table_drop_changefeedContext) { +func (p *YQLParser) Alter_table_drop_changefeed() (localctx IAlter_table_drop_changefeedContext) { localctx = NewAlter_table_drop_changefeedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 504, YQLv1Antlr4ParserRULE_alter_table_drop_changefeed) + p.EnterRule(localctx, 504, YQLParserRULE_alter_table_drop_changefeed) p.EnterOuterAlt(localctx, 1) { p.SetState(3169) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54713,7 +54713,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_drop_changefeed() (localctx IAlter_table } { p.SetState(3170) - p.Match(YQLv1Antlr4ParserCHANGEFEED) + p.Match(YQLParserCHANGEFEED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54765,13 +54765,13 @@ type Alter_table_alter_indexContext struct { func NewEmptyAlter_table_alter_indexContext() *Alter_table_alter_indexContext { var p = new(Alter_table_alter_indexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_index + p.RuleIndex = YQLParserRULE_alter_table_alter_index return p } func InitEmptyAlter_table_alter_indexContext(p *Alter_table_alter_indexContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_index + p.RuleIndex = YQLParserRULE_alter_table_alter_index } func (*Alter_table_alter_indexContext) IsAlter_table_alter_indexContext() {} @@ -54782,7 +54782,7 @@ func NewAlter_table_alter_indexContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_index + p.RuleIndex = YQLParserRULE_alter_table_alter_index return p } @@ -54790,11 +54790,11 @@ func NewAlter_table_alter_indexContext(parser antlr.Parser, parent antlr.ParserR func (s *Alter_table_alter_indexContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_alter_indexContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_table_alter_indexContext) INDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEX, 0) + return s.GetToken(YQLParserINDEX, 0) } func (s *Alter_table_alter_indexContext) An_id() IAn_idContext { @@ -54839,13 +54839,13 @@ func (s *Alter_table_alter_indexContext) ToStringTree(ruleNames []string, recog func (s *Alter_table_alter_indexContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_alter_index(s) } } func (s *Alter_table_alter_indexContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_alter_index(s) } } @@ -54853,13 +54853,13 @@ func (s *Alter_table_alter_indexContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Alter_table_alter_index() (localctx IAlter_table_alter_indexContext) { +func (p *YQLParser) Alter_table_alter_index() (localctx IAlter_table_alter_indexContext) { localctx = NewAlter_table_alter_indexContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 506, YQLv1Antlr4ParserRULE_alter_table_alter_index) + p.EnterRule(localctx, 506, YQLParserRULE_alter_table_alter_index) p.EnterOuterAlt(localctx, 1) { p.SetState(3173) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54867,7 +54867,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_alter_index() (localctx IAlter_table_alt } { p.SetState(3174) - p.Match(YQLv1Antlr4ParserINDEX) + p.Match(YQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54923,13 +54923,13 @@ type Column_schemaContext struct { func NewEmptyColumn_schemaContext() *Column_schemaContext { var p = new(Column_schemaContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_schema + p.RuleIndex = YQLParserRULE_column_schema return p } func InitEmptyColumn_schemaContext(p *Column_schemaContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_schema + p.RuleIndex = YQLParserRULE_column_schema } func (*Column_schemaContext) IsColumn_schemaContext() {} @@ -54940,7 +54940,7 @@ func NewColumn_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_column_schema + p.RuleIndex = YQLParserRULE_column_schema return p } @@ -55021,13 +55021,13 @@ func (s *Column_schemaContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Column_schemaContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterColumn_schema(s) } } func (s *Column_schemaContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitColumn_schema(s) } } @@ -55035,9 +55035,9 @@ func (s *Column_schemaContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Column_schema() (localctx IColumn_schemaContext) { +func (p *YQLParser) Column_schema() (localctx IColumn_schemaContext) { localctx = NewColumn_schemaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 508, YQLv1Antlr4ParserRULE_column_schema) + p.EnterRule(localctx, 508, YQLParserRULE_column_schema) var _la int p.EnterOuterAlt(localctx, 1) @@ -55057,7 +55057,7 @@ func (p *YQLv1Antlr4Parser) Column_schema() (localctx IColumn_schemaContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserFAMILY { + if _la == YQLParserFAMILY { { p.SetState(3180) p.Family_relation() @@ -55108,13 +55108,13 @@ type Family_relationContext struct { func NewEmptyFamily_relationContext() *Family_relationContext { var p = new(Family_relationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_relation + p.RuleIndex = YQLParserRULE_family_relation return p } func InitEmptyFamily_relationContext(p *Family_relationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_relation + p.RuleIndex = YQLParserRULE_family_relation } func (*Family_relationContext) IsFamily_relationContext() {} @@ -55125,7 +55125,7 @@ func NewFamily_relationContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_family_relation + p.RuleIndex = YQLParserRULE_family_relation return p } @@ -55133,7 +55133,7 @@ func NewFamily_relationContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Family_relationContext) GetParser() antlr.Parser { return s.parser } func (s *Family_relationContext) FAMILY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFAMILY, 0) + return s.GetToken(YQLParserFAMILY, 0) } func (s *Family_relationContext) An_id() IAn_idContext { @@ -55162,13 +55162,13 @@ func (s *Family_relationContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Family_relationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFamily_relation(s) } } func (s *Family_relationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFamily_relation(s) } } @@ -55176,13 +55176,13 @@ func (s *Family_relationContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Family_relation() (localctx IFamily_relationContext) { +func (p *YQLParser) Family_relation() (localctx IFamily_relationContext) { localctx = NewFamily_relationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 510, YQLv1Antlr4ParserRULE_family_relation) + p.EnterRule(localctx, 510, YQLParserRULE_family_relation) p.EnterOuterAlt(localctx, 1) { p.SetState(3185) - p.Match(YQLv1Antlr4ParserFAMILY) + p.Match(YQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55234,13 +55234,13 @@ type Opt_column_constraintsContext struct { func NewEmptyOpt_column_constraintsContext() *Opt_column_constraintsContext { var p = new(Opt_column_constraintsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_column_constraints + p.RuleIndex = YQLParserRULE_opt_column_constraints return p } func InitEmptyOpt_column_constraintsContext(p *Opt_column_constraintsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_column_constraints + p.RuleIndex = YQLParserRULE_opt_column_constraints } func (*Opt_column_constraintsContext) IsOpt_column_constraintsContext() {} @@ -55251,7 +55251,7 @@ func NewOpt_column_constraintsContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_column_constraints + p.RuleIndex = YQLParserRULE_opt_column_constraints return p } @@ -55259,11 +55259,11 @@ func NewOpt_column_constraintsContext(parser antlr.Parser, parent antlr.ParserRu func (s *Opt_column_constraintsContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_column_constraintsContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Opt_column_constraintsContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFAULT, 0) + return s.GetToken(YQLParserDEFAULT, 0) } func (s *Opt_column_constraintsContext) Expr() IExprContext { @@ -55283,7 +55283,7 @@ func (s *Opt_column_constraintsContext) Expr() IExprContext { } func (s *Opt_column_constraintsContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Opt_column_constraintsContext) GetRuleContext() antlr.RuleContext { @@ -55296,13 +55296,13 @@ func (s *Opt_column_constraintsContext) ToStringTree(ruleNames []string, recog a func (s *Opt_column_constraintsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOpt_column_constraints(s) } } func (s *Opt_column_constraintsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOpt_column_constraints(s) } } @@ -55310,9 +55310,9 @@ func (s *Opt_column_constraintsContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Opt_column_constraints() (localctx IOpt_column_constraintsContext) { +func (p *YQLParser) Opt_column_constraints() (localctx IOpt_column_constraintsContext) { localctx = NewOpt_column_constraintsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 512, YQLv1Antlr4ParserRULE_opt_column_constraints) + p.EnterRule(localctx, 512, YQLParserRULE_opt_column_constraints) var _la int p.EnterOuterAlt(localctx, 1) @@ -55324,7 +55324,7 @@ func (p *YQLv1Antlr4Parser) Opt_column_constraints() (localctx IOpt_column_const _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT || _la == YQLv1Antlr4ParserNULL { + if _la == YQLParserNOT || _la == YQLParserNULL { p.SetState(3189) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -55333,10 +55333,10 @@ func (p *YQLv1Antlr4Parser) Opt_column_constraints() (localctx IOpt_column_const _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserNOT { + if _la == YQLParserNOT { { p.SetState(3188) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55346,7 +55346,7 @@ func (p *YQLv1Antlr4Parser) Opt_column_constraints() (localctx IOpt_column_const } { p.SetState(3191) - p.Match(YQLv1Antlr4ParserNULL) + p.Match(YQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55362,10 +55362,10 @@ func (p *YQLv1Antlr4Parser) Opt_column_constraints() (localctx IOpt_column_const _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDEFAULT { + if _la == YQLParserDEFAULT { { p.SetState(3194) - p.Match(YQLv1Antlr4ParserDEFAULT) + p.Match(YQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55418,13 +55418,13 @@ type Column_order_by_specificationContext struct { func NewEmptyColumn_order_by_specificationContext() *Column_order_by_specificationContext { var p = new(Column_order_by_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_order_by_specification + p.RuleIndex = YQLParserRULE_column_order_by_specification return p } func InitEmptyColumn_order_by_specificationContext(p *Column_order_by_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_column_order_by_specification + p.RuleIndex = YQLParserRULE_column_order_by_specification } func (*Column_order_by_specificationContext) IsColumn_order_by_specificationContext() {} @@ -55435,7 +55435,7 @@ func NewColumn_order_by_specificationContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_column_order_by_specification + p.RuleIndex = YQLParserRULE_column_order_by_specification return p } @@ -55459,11 +55459,11 @@ func (s *Column_order_by_specificationContext) An_id() IAn_idContext { } func (s *Column_order_by_specificationContext) ASC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASC, 0) + return s.GetToken(YQLParserASC, 0) } func (s *Column_order_by_specificationContext) DESC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDESC, 0) + return s.GetToken(YQLParserDESC, 0) } func (s *Column_order_by_specificationContext) GetRuleContext() antlr.RuleContext { @@ -55476,13 +55476,13 @@ func (s *Column_order_by_specificationContext) ToStringTree(ruleNames []string, func (s *Column_order_by_specificationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterColumn_order_by_specification(s) } } func (s *Column_order_by_specificationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitColumn_order_by_specification(s) } } @@ -55490,9 +55490,9 @@ func (s *Column_order_by_specificationContext) ExitRule(listener antlr.ParseTree -func (p *YQLv1Antlr4Parser) Column_order_by_specification() (localctx IColumn_order_by_specificationContext) { +func (p *YQLParser) Column_order_by_specification() (localctx IColumn_order_by_specificationContext) { localctx = NewColumn_order_by_specificationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 514, YQLv1Antlr4ParserRULE_column_order_by_specification) + p.EnterRule(localctx, 514, YQLParserRULE_column_order_by_specification) var _la int p.EnterOuterAlt(localctx, 1) @@ -55508,12 +55508,12 @@ func (p *YQLv1Antlr4Parser) Column_order_by_specification() (localctx IColumn_or _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserASC || _la == YQLv1Antlr4ParserDESC { + if _la == YQLParserASC || _la == YQLParserDESC { { p.SetState(3199) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserASC || _la == YQLv1Antlr4ParserDESC) { + if !(_la == YQLParserASC || _la == YQLParserDESC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -55573,13 +55573,13 @@ type Table_constraintContext struct { func NewEmptyTable_constraintContext() *Table_constraintContext { var p = new(Table_constraintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_constraint + p.RuleIndex = YQLParserRULE_table_constraint return p } func InitEmptyTable_constraintContext(p *Table_constraintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_constraint + p.RuleIndex = YQLParserRULE_table_constraint } func (*Table_constraintContext) IsTable_constraintContext() {} @@ -55590,7 +55590,7 @@ func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_constraint + p.RuleIndex = YQLParserRULE_table_constraint return p } @@ -55598,15 +55598,15 @@ func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Table_constraintContext) GetParser() antlr.Parser { return s.parser } func (s *Table_constraintContext) PRIMARY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRIMARY, 0) + return s.GetToken(YQLParserPRIMARY, 0) } func (s *Table_constraintContext) KEY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserKEY, 0) + return s.GetToken(YQLParserKEY, 0) } func (s *Table_constraintContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Table_constraintContext) AllAn_id() []IAn_idContext { @@ -55651,27 +55651,27 @@ func (s *Table_constraintContext) An_id(i int) IAn_idContext { } func (s *Table_constraintContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Table_constraintContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Table_constraintContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Table_constraintContext) PARTITION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARTITION, 0) + return s.GetToken(YQLParserPARTITION, 0) } func (s *Table_constraintContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Table_constraintContext) ORDER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserORDER, 0) + return s.GetToken(YQLParserORDER, 0) } func (s *Table_constraintContext) AllColumn_order_by_specification() []IColumn_order_by_specificationContext { @@ -55725,13 +55725,13 @@ func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_constraint(s) } } func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_constraint(s) } } @@ -55739,9 +55739,9 @@ func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContext) { +func (p *YQLParser) Table_constraint() (localctx ITable_constraintContext) { localctx = NewTable_constraintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 516, YQLv1Antlr4ParserRULE_table_constraint) + p.EnterRule(localctx, 516, YQLParserRULE_table_constraint) var _la int p.SetState(3241) @@ -55751,11 +55751,11 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserPRIMARY: + case YQLParserPRIMARY: p.EnterOuterAlt(localctx, 1) { p.SetState(3202) - p.Match(YQLv1Antlr4ParserPRIMARY) + p.Match(YQLParserPRIMARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55763,7 +55763,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3203) - p.Match(YQLv1Antlr4ParserKEY) + p.Match(YQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55771,7 +55771,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3204) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55789,10 +55789,10 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3206) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55813,7 +55813,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3213) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55821,11 +55821,11 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } - case YQLv1Antlr4ParserPARTITION: + case YQLParserPARTITION: p.EnterOuterAlt(localctx, 2) { p.SetState(3215) - p.Match(YQLv1Antlr4ParserPARTITION) + p.Match(YQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55833,7 +55833,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3216) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55841,7 +55841,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3217) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55859,10 +55859,10 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3219) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55883,7 +55883,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3226) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55891,11 +55891,11 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } - case YQLv1Antlr4ParserORDER: + case YQLParserORDER: p.EnterOuterAlt(localctx, 3) { p.SetState(3228) - p.Match(YQLv1Antlr4ParserORDER) + p.Match(YQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55903,7 +55903,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3229) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55911,7 +55911,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3230) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55929,10 +55929,10 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3232) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55953,7 +55953,7 @@ func (p *YQLv1Antlr4Parser) Table_constraint() (localctx ITable_constraintContex } { p.SetState(3239) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56017,13 +56017,13 @@ type Table_indexContext struct { func NewEmptyTable_indexContext() *Table_indexContext { var p = new(Table_indexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_index + p.RuleIndex = YQLParserRULE_table_index return p } func InitEmptyTable_indexContext(p *Table_indexContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_index + p.RuleIndex = YQLParserRULE_table_index } func (*Table_indexContext) IsTable_indexContext() {} @@ -56034,7 +56034,7 @@ func NewTable_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_index + p.RuleIndex = YQLParserRULE_table_index return p } @@ -56042,7 +56042,7 @@ func NewTable_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Table_indexContext) GetParser() antlr.Parser { return s.parser } func (s *Table_indexContext) INDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEX, 0) + return s.GetToken(YQLParserINDEX, 0) } func (s *Table_indexContext) An_id() IAn_idContext { @@ -56078,15 +56078,15 @@ func (s *Table_indexContext) Table_index_type() ITable_index_typeContext { } func (s *Table_indexContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Table_indexContext) AllLPAREN() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserLPAREN) + return s.GetTokens(YQLParserLPAREN) } func (s *Table_indexContext) LPAREN(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, i) + return s.GetToken(YQLParserLPAREN, i) } func (s *Table_indexContext) AllAn_id_schema() []IAn_id_schemaContext { @@ -56131,23 +56131,23 @@ func (s *Table_indexContext) An_id_schema(i int) IAn_id_schemaContext { } func (s *Table_indexContext) AllRPAREN() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserRPAREN) + return s.GetTokens(YQLParserRPAREN) } func (s *Table_indexContext) RPAREN(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, i) + return s.GetToken(YQLParserRPAREN, i) } func (s *Table_indexContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Table_indexContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Table_indexContext) COVER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOVER, 0) + return s.GetToken(YQLParserCOVER, 0) } func (s *Table_indexContext) With_index_settings() IWith_index_settingsContext { @@ -56176,13 +56176,13 @@ func (s *Table_indexContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Table_indexContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_index(s) } } func (s *Table_indexContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_index(s) } } @@ -56190,15 +56190,15 @@ func (s *Table_indexContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { +func (p *YQLParser) Table_index() (localctx ITable_indexContext) { localctx = NewTable_indexContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 518, YQLv1Antlr4ParserRULE_table_index) + p.EnterRule(localctx, 518, YQLParserRULE_table_index) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3243) - p.Match(YQLv1Antlr4ParserINDEX) + p.Match(YQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56214,7 +56214,7 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { } { p.SetState(3246) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56222,7 +56222,7 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { } { p.SetState(3247) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56240,10 +56240,10 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3249) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56264,7 +56264,7 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { } { p.SetState(3256) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56278,10 +56278,10 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOVER { + if _la == YQLParserCOVER { { p.SetState(3257) - p.Match(YQLv1Antlr4ParserCOVER) + p.Match(YQLParserCOVER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56289,7 +56289,7 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { } { p.SetState(3258) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56307,10 +56307,10 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3260) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56331,7 +56331,7 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { } { p.SetState(3267) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56347,7 +56347,7 @@ func (p *YQLv1Antlr4Parser) Table_index() (localctx ITable_indexContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(3271) p.With_index_settings() @@ -56396,13 +56396,13 @@ type Table_index_typeContext struct { func NewEmptyTable_index_typeContext() *Table_index_typeContext { var p = new(Table_index_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_index_type + p.RuleIndex = YQLParserRULE_table_index_type return p } func InitEmptyTable_index_typeContext(p *Table_index_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_index_type + p.RuleIndex = YQLParserRULE_table_index_type } func (*Table_index_typeContext) IsTable_index_typeContext() {} @@ -56413,7 +56413,7 @@ func NewTable_index_typeContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_index_type + p.RuleIndex = YQLParserRULE_table_index_type return p } @@ -56453,7 +56453,7 @@ func (s *Table_index_typeContext) Local_index() ILocal_indexContext { } func (s *Table_index_typeContext) USING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSING, 0) + return s.GetToken(YQLParserUSING, 0) } func (s *Table_index_typeContext) Index_subtype() IIndex_subtypeContext { @@ -56482,13 +56482,13 @@ func (s *Table_index_typeContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Table_index_typeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_index_type(s) } } func (s *Table_index_typeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_index_type(s) } } @@ -56496,9 +56496,9 @@ func (s *Table_index_typeContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_index_type() (localctx ITable_index_typeContext) { +func (p *YQLParser) Table_index_type() (localctx ITable_index_typeContext) { localctx = NewTable_index_typeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 520, YQLv1Antlr4ParserRULE_table_index_type) + p.EnterRule(localctx, 520, YQLParserRULE_table_index_type) var _la int p.EnterOuterAlt(localctx, 1) @@ -56509,14 +56509,14 @@ func (p *YQLv1Antlr4Parser) Table_index_type() (localctx ITable_index_typeContex } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserGLOBAL: + case YQLParserGLOBAL: { p.SetState(3274) p.Global_index() } - case YQLv1Antlr4ParserLOCAL: + case YQLParserLOCAL: { p.SetState(3275) p.Local_index() @@ -56536,10 +56536,10 @@ func (p *YQLv1Antlr4Parser) Table_index_type() (localctx ITable_index_typeContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserUSING { + if _la == YQLParserUSING { { p.SetState(3278) - p.Match(YQLv1Antlr4ParserUSING) + p.Match(YQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56593,13 +56593,13 @@ type Global_indexContext struct { func NewEmptyGlobal_indexContext() *Global_indexContext { var p = new(Global_indexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_global_index + p.RuleIndex = YQLParserRULE_global_index return p } func InitEmptyGlobal_indexContext(p *Global_indexContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_global_index + p.RuleIndex = YQLParserRULE_global_index } func (*Global_indexContext) IsGlobal_indexContext() {} @@ -56610,7 +56610,7 @@ func NewGlobal_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_global_index + p.RuleIndex = YQLParserRULE_global_index return p } @@ -56618,19 +56618,19 @@ func NewGlobal_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Global_indexContext) GetParser() antlr.Parser { return s.parser } func (s *Global_indexContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGLOBAL, 0) + return s.GetToken(YQLParserGLOBAL, 0) } func (s *Global_indexContext) UNIQUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNIQUE, 0) + return s.GetToken(YQLParserUNIQUE, 0) } func (s *Global_indexContext) SYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYNC, 0) + return s.GetToken(YQLParserSYNC, 0) } func (s *Global_indexContext) ASYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYNC, 0) + return s.GetToken(YQLParserASYNC, 0) } func (s *Global_indexContext) GetRuleContext() antlr.RuleContext { @@ -56643,13 +56643,13 @@ func (s *Global_indexContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Global_indexContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterGlobal_index(s) } } func (s *Global_indexContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitGlobal_index(s) } } @@ -56657,15 +56657,15 @@ func (s *Global_indexContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Global_index() (localctx IGlobal_indexContext) { +func (p *YQLParser) Global_index() (localctx IGlobal_indexContext) { localctx = NewGlobal_indexContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 522, YQLv1Antlr4ParserRULE_global_index) + p.EnterRule(localctx, 522, YQLParserRULE_global_index) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3282) - p.Match(YQLv1Antlr4ParserGLOBAL) + p.Match(YQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56679,10 +56679,10 @@ func (p *YQLv1Antlr4Parser) Global_index() (localctx IGlobal_indexContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserUNIQUE { + if _la == YQLParserUNIQUE { { p.SetState(3283) - p.Match(YQLv1Antlr4ParserUNIQUE) + p.Match(YQLParserUNIQUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56698,12 +56698,12 @@ func (p *YQLv1Antlr4Parser) Global_index() (localctx IGlobal_indexContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserASYNC || _la == YQLv1Antlr4ParserSYNC { + if _la == YQLParserASYNC || _la == YQLParserSYNC { { p.SetState(3286) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserASYNC || _la == YQLv1Antlr4ParserSYNC) { + if !(_la == YQLParserASYNC || _la == YQLParserSYNC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -56751,13 +56751,13 @@ type Local_indexContext struct { func NewEmptyLocal_indexContext() *Local_indexContext { var p = new(Local_indexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_local_index + p.RuleIndex = YQLParserRULE_local_index return p } func InitEmptyLocal_indexContext(p *Local_indexContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_local_index + p.RuleIndex = YQLParserRULE_local_index } func (*Local_indexContext) IsLocal_indexContext() {} @@ -56768,7 +56768,7 @@ func NewLocal_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_local_index + p.RuleIndex = YQLParserRULE_local_index return p } @@ -56776,7 +56776,7 @@ func NewLocal_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Local_indexContext) GetParser() antlr.Parser { return s.parser } func (s *Local_indexContext) LOCAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLOCAL, 0) + return s.GetToken(YQLParserLOCAL, 0) } func (s *Local_indexContext) GetRuleContext() antlr.RuleContext { @@ -56789,13 +56789,13 @@ func (s *Local_indexContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Local_indexContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterLocal_index(s) } } func (s *Local_indexContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitLocal_index(s) } } @@ -56803,13 +56803,13 @@ func (s *Local_indexContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Local_index() (localctx ILocal_indexContext) { +func (p *YQLParser) Local_index() (localctx ILocal_indexContext) { localctx = NewLocal_indexContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 524, YQLv1Antlr4ParserRULE_local_index) + p.EnterRule(localctx, 524, YQLParserRULE_local_index) p.EnterOuterAlt(localctx, 1) { p.SetState(3289) - p.Match(YQLv1Antlr4ParserLOCAL) + p.Match(YQLParserLOCAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56854,13 +56854,13 @@ type Index_subtypeContext struct { func NewEmptyIndex_subtypeContext() *Index_subtypeContext { var p = new(Index_subtypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_index_subtype + p.RuleIndex = YQLParserRULE_index_subtype return p } func InitEmptyIndex_subtypeContext(p *Index_subtypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_index_subtype + p.RuleIndex = YQLParserRULE_index_subtype } func (*Index_subtypeContext) IsIndex_subtypeContext() {} @@ -56871,7 +56871,7 @@ func NewIndex_subtypeContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_index_subtype + p.RuleIndex = YQLParserRULE_index_subtype return p } @@ -56904,13 +56904,13 @@ func (s *Index_subtypeContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Index_subtypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIndex_subtype(s) } } func (s *Index_subtypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIndex_subtype(s) } } @@ -56918,9 +56918,9 @@ func (s *Index_subtypeContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Index_subtype() (localctx IIndex_subtypeContext) { +func (p *YQLParser) Index_subtype() (localctx IIndex_subtypeContext) { localctx = NewIndex_subtypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 526, YQLv1Antlr4ParserRULE_index_subtype) + p.EnterRule(localctx, 526, YQLParserRULE_index_subtype) p.EnterOuterAlt(localctx, 1) { p.SetState(3291) @@ -56971,13 +56971,13 @@ type With_index_settingsContext struct { func NewEmptyWith_index_settingsContext() *With_index_settingsContext { var p = new(With_index_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_with_index_settings + p.RuleIndex = YQLParserRULE_with_index_settings return p } func InitEmptyWith_index_settingsContext(p *With_index_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_with_index_settings + p.RuleIndex = YQLParserRULE_with_index_settings } func (*With_index_settingsContext) IsWith_index_settingsContext() {} @@ -56988,7 +56988,7 @@ func NewWith_index_settingsContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_with_index_settings + p.RuleIndex = YQLParserRULE_with_index_settings return p } @@ -56996,11 +56996,11 @@ func NewWith_index_settingsContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *With_index_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *With_index_settingsContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *With_index_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *With_index_settingsContext) AllIndex_setting_entry() []IIndex_setting_entryContext { @@ -57045,15 +57045,15 @@ func (s *With_index_settingsContext) Index_setting_entry(i int) IIndex_setting_e } func (s *With_index_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *With_index_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *With_index_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *With_index_settingsContext) GetRuleContext() antlr.RuleContext { @@ -57066,13 +57066,13 @@ func (s *With_index_settingsContext) ToStringTree(ruleNames []string, recog antl func (s *With_index_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWith_index_settings(s) } } func (s *With_index_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWith_index_settings(s) } } @@ -57080,9 +57080,9 @@ func (s *With_index_settingsContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) With_index_settings() (localctx IWith_index_settingsContext) { +func (p *YQLParser) With_index_settings() (localctx IWith_index_settingsContext) { localctx = NewWith_index_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 528, YQLv1Antlr4ParserRULE_with_index_settings) + p.EnterRule(localctx, 528, YQLParserRULE_with_index_settings) var _la int var _alt int @@ -57090,7 +57090,7 @@ func (p *YQLv1Antlr4Parser) With_index_settings() (localctx IWith_index_settings p.EnterOuterAlt(localctx, 1) { p.SetState(3293) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57098,7 +57098,7 @@ func (p *YQLv1Antlr4Parser) With_index_settings() (localctx IWith_index_settings } { p.SetState(3294) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57121,7 +57121,7 @@ func (p *YQLv1Antlr4Parser) With_index_settings() (localctx IWith_index_settings if _alt == 1 { { p.SetState(3296) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57152,10 +57152,10 @@ func (p *YQLv1Antlr4Parser) With_index_settings() (localctx IWith_index_settings _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3303) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57165,7 +57165,7 @@ func (p *YQLv1Antlr4Parser) With_index_settings() (localctx IWith_index_settings } { p.SetState(3306) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57212,13 +57212,13 @@ type Index_setting_entryContext struct { func NewEmptyIndex_setting_entryContext() *Index_setting_entryContext { var p = new(Index_setting_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_index_setting_entry + p.RuleIndex = YQLParserRULE_index_setting_entry return p } func InitEmptyIndex_setting_entryContext(p *Index_setting_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_index_setting_entry + p.RuleIndex = YQLParserRULE_index_setting_entry } func (*Index_setting_entryContext) IsIndex_setting_entryContext() {} @@ -57229,7 +57229,7 @@ func NewIndex_setting_entryContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_index_setting_entry + p.RuleIndex = YQLParserRULE_index_setting_entry return p } @@ -57253,7 +57253,7 @@ func (s *Index_setting_entryContext) An_id() IAn_idContext { } func (s *Index_setting_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Index_setting_entryContext) Index_setting_value() IIndex_setting_valueContext { @@ -57282,13 +57282,13 @@ func (s *Index_setting_entryContext) ToStringTree(ruleNames []string, recog antl func (s *Index_setting_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIndex_setting_entry(s) } } func (s *Index_setting_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIndex_setting_entry(s) } } @@ -57296,9 +57296,9 @@ func (s *Index_setting_entryContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Index_setting_entry() (localctx IIndex_setting_entryContext) { +func (p *YQLParser) Index_setting_entry() (localctx IIndex_setting_entryContext) { localctx = NewIndex_setting_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 530, YQLv1Antlr4ParserRULE_index_setting_entry) + p.EnterRule(localctx, 530, YQLParserRULE_index_setting_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(3308) @@ -57306,7 +57306,7 @@ func (p *YQLv1Antlr4Parser) Index_setting_entry() (localctx IIndex_setting_entry } { p.SetState(3309) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57358,13 +57358,13 @@ type Index_setting_valueContext struct { func NewEmptyIndex_setting_valueContext() *Index_setting_valueContext { var p = new(Index_setting_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_index_setting_value + p.RuleIndex = YQLParserRULE_index_setting_value return p } func InitEmptyIndex_setting_valueContext(p *Index_setting_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_index_setting_value + p.RuleIndex = YQLParserRULE_index_setting_value } func (*Index_setting_valueContext) IsIndex_setting_valueContext() {} @@ -57375,7 +57375,7 @@ func NewIndex_setting_valueContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_index_setting_value + p.RuleIndex = YQLParserRULE_index_setting_value return p } @@ -57399,7 +57399,7 @@ func (s *Index_setting_valueContext) Id_or_type() IId_or_typeContext { } func (s *Index_setting_valueContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Index_setting_valueContext) Integer() IIntegerContext { @@ -57444,13 +57444,13 @@ func (s *Index_setting_valueContext) ToStringTree(ruleNames []string, recog antl func (s *Index_setting_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIndex_setting_value(s) } } func (s *Index_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIndex_setting_value(s) } } @@ -57458,9 +57458,9 @@ func (s *Index_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Index_setting_value() (localctx IIndex_setting_valueContext) { +func (p *YQLParser) Index_setting_value() (localctx IIndex_setting_valueContext) { localctx = NewIndex_setting_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 532, YQLv1Antlr4ParserRULE_index_setting_value) + p.EnterRule(localctx, 532, YQLParserRULE_index_setting_value) p.SetState(3316) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -57468,7 +57468,7 @@ func (p *YQLv1Antlr4Parser) Index_setting_value() (localctx IIndex_setting_value } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(3312) @@ -57476,11 +57476,11 @@ func (p *YQLv1Antlr4Parser) Index_setting_value() (localctx IIndex_setting_value } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(3313) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57488,7 +57488,7 @@ func (p *YQLv1Antlr4Parser) Index_setting_value() (localctx IIndex_setting_value } - case YQLv1Antlr4ParserDIGITS, YQLv1Antlr4ParserINTEGER_VALUE: + case YQLParserDIGITS, YQLParserINTEGER_VALUE: p.EnterOuterAlt(localctx, 3) { p.SetState(3314) @@ -57496,7 +57496,7 @@ func (p *YQLv1Antlr4Parser) Index_setting_value() (localctx IIndex_setting_value } - case YQLv1Antlr4ParserFALSE, YQLv1Antlr4ParserTRUE: + case YQLParserFALSE, YQLParserTRUE: p.EnterOuterAlt(localctx, 4) { p.SetState(3315) @@ -57552,13 +57552,13 @@ type ChangefeedContext struct { func NewEmptyChangefeedContext() *ChangefeedContext { var p = new(ChangefeedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed + p.RuleIndex = YQLParserRULE_changefeed return p } func InitEmptyChangefeedContext(p *ChangefeedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed + p.RuleIndex = YQLParserRULE_changefeed } func (*ChangefeedContext) IsChangefeedContext() {} @@ -57569,7 +57569,7 @@ func NewChangefeedContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed + p.RuleIndex = YQLParserRULE_changefeed return p } @@ -57577,7 +57577,7 @@ func NewChangefeedContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *ChangefeedContext) GetParser() antlr.Parser { return s.parser } func (s *ChangefeedContext) CHANGEFEED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCHANGEFEED, 0) + return s.GetToken(YQLParserCHANGEFEED, 0) } func (s *ChangefeedContext) An_id() IAn_idContext { @@ -57597,11 +57597,11 @@ func (s *ChangefeedContext) An_id() IAn_idContext { } func (s *ChangefeedContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *ChangefeedContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *ChangefeedContext) Changefeed_settings() IChangefeed_settingsContext { @@ -57621,7 +57621,7 @@ func (s *ChangefeedContext) Changefeed_settings() IChangefeed_settingsContext { } func (s *ChangefeedContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *ChangefeedContext) GetRuleContext() antlr.RuleContext { @@ -57634,13 +57634,13 @@ func (s *ChangefeedContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *ChangefeedContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterChangefeed(s) } } func (s *ChangefeedContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitChangefeed(s) } } @@ -57648,13 +57648,13 @@ func (s *ChangefeedContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Changefeed() (localctx IChangefeedContext) { +func (p *YQLParser) Changefeed() (localctx IChangefeedContext) { localctx = NewChangefeedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 534, YQLv1Antlr4ParserRULE_changefeed) + p.EnterRule(localctx, 534, YQLParserRULE_changefeed) p.EnterOuterAlt(localctx, 1) { p.SetState(3318) - p.Match(YQLv1Antlr4ParserCHANGEFEED) + p.Match(YQLParserCHANGEFEED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57666,7 +57666,7 @@ func (p *YQLv1Antlr4Parser) Changefeed() (localctx IChangefeedContext) { } { p.SetState(3320) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57674,7 +57674,7 @@ func (p *YQLv1Antlr4Parser) Changefeed() (localctx IChangefeedContext) { } { p.SetState(3321) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57686,7 +57686,7 @@ func (p *YQLv1Antlr4Parser) Changefeed() (localctx IChangefeedContext) { } { p.SetState(3323) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57734,13 +57734,13 @@ type Changefeed_settingsContext struct { func NewEmptyChangefeed_settingsContext() *Changefeed_settingsContext { var p = new(Changefeed_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_settings + p.RuleIndex = YQLParserRULE_changefeed_settings return p } func InitEmptyChangefeed_settingsContext(p *Changefeed_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_settings + p.RuleIndex = YQLParserRULE_changefeed_settings } func (*Changefeed_settingsContext) IsChangefeed_settingsContext() {} @@ -57751,7 +57751,7 @@ func NewChangefeed_settingsContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_settings + p.RuleIndex = YQLParserRULE_changefeed_settings return p } @@ -57800,11 +57800,11 @@ func (s *Changefeed_settingsContext) Changefeed_settings_entry(i int) IChangefee } func (s *Changefeed_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Changefeed_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Changefeed_settingsContext) GetRuleContext() antlr.RuleContext { @@ -57817,13 +57817,13 @@ func (s *Changefeed_settingsContext) ToStringTree(ruleNames []string, recog antl func (s *Changefeed_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterChangefeed_settings(s) } } func (s *Changefeed_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitChangefeed_settings(s) } } @@ -57831,9 +57831,9 @@ func (s *Changefeed_settingsContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Changefeed_settings() (localctx IChangefeed_settingsContext) { +func (p *YQLParser) Changefeed_settings() (localctx IChangefeed_settingsContext) { localctx = NewChangefeed_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 536, YQLv1Antlr4ParserRULE_changefeed_settings) + p.EnterRule(localctx, 536, YQLParserRULE_changefeed_settings) var _la int p.EnterOuterAlt(localctx, 1) @@ -57849,10 +57849,10 @@ func (p *YQLv1Antlr4Parser) Changefeed_settings() (localctx IChangefeed_settings _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3326) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57912,13 +57912,13 @@ type Changefeed_settings_entryContext struct { func NewEmptyChangefeed_settings_entryContext() *Changefeed_settings_entryContext { var p = new(Changefeed_settings_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_settings_entry + p.RuleIndex = YQLParserRULE_changefeed_settings_entry return p } func InitEmptyChangefeed_settings_entryContext(p *Changefeed_settings_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_settings_entry + p.RuleIndex = YQLParserRULE_changefeed_settings_entry } func (*Changefeed_settings_entryContext) IsChangefeed_settings_entryContext() {} @@ -57929,7 +57929,7 @@ func NewChangefeed_settings_entryContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_settings_entry + p.RuleIndex = YQLParserRULE_changefeed_settings_entry return p } @@ -57953,7 +57953,7 @@ func (s *Changefeed_settings_entryContext) An_id() IAn_idContext { } func (s *Changefeed_settings_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Changefeed_settings_entryContext) Changefeed_setting_value() IChangefeed_setting_valueContext { @@ -57982,13 +57982,13 @@ func (s *Changefeed_settings_entryContext) ToStringTree(ruleNames []string, reco func (s *Changefeed_settings_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterChangefeed_settings_entry(s) } } func (s *Changefeed_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitChangefeed_settings_entry(s) } } @@ -57996,9 +57996,9 @@ func (s *Changefeed_settings_entryContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Changefeed_settings_entry() (localctx IChangefeed_settings_entryContext) { +func (p *YQLParser) Changefeed_settings_entry() (localctx IChangefeed_settings_entryContext) { localctx = NewChangefeed_settings_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 538, YQLv1Antlr4ParserRULE_changefeed_settings_entry) + p.EnterRule(localctx, 538, YQLParserRULE_changefeed_settings_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(3333) @@ -58006,7 +58006,7 @@ func (p *YQLv1Antlr4Parser) Changefeed_settings_entry() (localctx IChangefeed_se } { p.SetState(3334) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58055,13 +58055,13 @@ type Changefeed_setting_valueContext struct { func NewEmptyChangefeed_setting_valueContext() *Changefeed_setting_valueContext { var p = new(Changefeed_setting_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_setting_value + p.RuleIndex = YQLParserRULE_changefeed_setting_value return p } func InitEmptyChangefeed_setting_valueContext(p *Changefeed_setting_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_setting_value + p.RuleIndex = YQLParserRULE_changefeed_setting_value } func (*Changefeed_setting_valueContext) IsChangefeed_setting_valueContext() {} @@ -58072,7 +58072,7 @@ func NewChangefeed_setting_valueContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_setting_value + p.RuleIndex = YQLParserRULE_changefeed_setting_value return p } @@ -58105,13 +58105,13 @@ func (s *Changefeed_setting_valueContext) ToStringTree(ruleNames []string, recog func (s *Changefeed_setting_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterChangefeed_setting_value(s) } } func (s *Changefeed_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitChangefeed_setting_value(s) } } @@ -58119,9 +58119,9 @@ func (s *Changefeed_setting_valueContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Changefeed_setting_value() (localctx IChangefeed_setting_valueContext) { +func (p *YQLParser) Changefeed_setting_value() (localctx IChangefeed_setting_valueContext) { localctx = NewChangefeed_setting_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 540, YQLv1Antlr4ParserRULE_changefeed_setting_value) + p.EnterRule(localctx, 540, YQLParserRULE_changefeed_setting_value) p.EnterOuterAlt(localctx, 1) { p.SetState(3337) @@ -58170,13 +58170,13 @@ type Changefeed_alter_settingsContext struct { func NewEmptyChangefeed_alter_settingsContext() *Changefeed_alter_settingsContext { var p = new(Changefeed_alter_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_alter_settings + p.RuleIndex = YQLParserRULE_changefeed_alter_settings return p } func InitEmptyChangefeed_alter_settingsContext(p *Changefeed_alter_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_alter_settings + p.RuleIndex = YQLParserRULE_changefeed_alter_settings } func (*Changefeed_alter_settingsContext) IsChangefeed_alter_settingsContext() {} @@ -58187,7 +58187,7 @@ func NewChangefeed_alter_settingsContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_changefeed_alter_settings + p.RuleIndex = YQLParserRULE_changefeed_alter_settings return p } @@ -58195,15 +58195,15 @@ func NewChangefeed_alter_settingsContext(parser antlr.Parser, parent antlr.Parse func (s *Changefeed_alter_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *Changefeed_alter_settingsContext) DISABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISABLE, 0) + return s.GetToken(YQLParserDISABLE, 0) } func (s *Changefeed_alter_settingsContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Changefeed_alter_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Changefeed_alter_settingsContext) Changefeed_settings() IChangefeed_settingsContext { @@ -58223,7 +58223,7 @@ func (s *Changefeed_alter_settingsContext) Changefeed_settings() IChangefeed_set } func (s *Changefeed_alter_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Changefeed_alter_settingsContext) GetRuleContext() antlr.RuleContext { @@ -58236,13 +58236,13 @@ func (s *Changefeed_alter_settingsContext) ToStringTree(ruleNames []string, reco func (s *Changefeed_alter_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterChangefeed_alter_settings(s) } } func (s *Changefeed_alter_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitChangefeed_alter_settings(s) } } @@ -58250,9 +58250,9 @@ func (s *Changefeed_alter_settingsContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Changefeed_alter_settings() (localctx IChangefeed_alter_settingsContext) { +func (p *YQLParser) Changefeed_alter_settings() (localctx IChangefeed_alter_settingsContext) { localctx = NewChangefeed_alter_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 542, YQLv1Antlr4ParserRULE_changefeed_alter_settings) + p.EnterRule(localctx, 542, YQLParserRULE_changefeed_alter_settings) p.SetState(3345) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -58260,11 +58260,11 @@ func (p *YQLv1Antlr4Parser) Changefeed_alter_settings() (localctx IChangefeed_al } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDISABLE: + case YQLParserDISABLE: p.EnterOuterAlt(localctx, 1) { p.SetState(3339) - p.Match(YQLv1Antlr4ParserDISABLE) + p.Match(YQLParserDISABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58272,11 +58272,11 @@ func (p *YQLv1Antlr4Parser) Changefeed_alter_settings() (localctx IChangefeed_al } - case YQLv1Antlr4ParserSET: + case YQLParserSET: p.EnterOuterAlt(localctx, 2) { p.SetState(3340) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58284,7 +58284,7 @@ func (p *YQLv1Antlr4Parser) Changefeed_alter_settings() (localctx IChangefeed_al } { p.SetState(3341) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58296,7 +58296,7 @@ func (p *YQLv1Antlr4Parser) Changefeed_alter_settings() (localctx IChangefeed_al } { p.SetState(3343) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58349,13 +58349,13 @@ type Alter_table_setting_entryContext struct { func NewEmptyAlter_table_setting_entryContext() *Alter_table_setting_entryContext { var p = new(Alter_table_setting_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_setting_entry + p.RuleIndex = YQLParserRULE_alter_table_setting_entry return p } func InitEmptyAlter_table_setting_entryContext(p *Alter_table_setting_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_setting_entry + p.RuleIndex = YQLParserRULE_alter_table_setting_entry } func (*Alter_table_setting_entryContext) IsAlter_table_setting_entryContext() {} @@ -58366,7 +58366,7 @@ func NewAlter_table_setting_entryContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_setting_entry + p.RuleIndex = YQLParserRULE_alter_table_setting_entry return p } @@ -58390,7 +58390,7 @@ func (s *Alter_table_setting_entryContext) An_id() IAn_idContext { } func (s *Alter_table_setting_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Alter_table_setting_entryContext) Table_setting_value() ITable_setting_valueContext { @@ -58419,13 +58419,13 @@ func (s *Alter_table_setting_entryContext) ToStringTree(ruleNames []string, reco func (s *Alter_table_setting_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_setting_entry(s) } } func (s *Alter_table_setting_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_setting_entry(s) } } @@ -58433,9 +58433,9 @@ func (s *Alter_table_setting_entryContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Alter_table_setting_entry() (localctx IAlter_table_setting_entryContext) { +func (p *YQLParser) Alter_table_setting_entry() (localctx IAlter_table_setting_entryContext) { localctx = NewAlter_table_setting_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 544, YQLv1Antlr4ParserRULE_alter_table_setting_entry) + p.EnterRule(localctx, 544, YQLParserRULE_alter_table_setting_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(3347) @@ -58443,7 +58443,7 @@ func (p *YQLv1Antlr4Parser) Alter_table_setting_entry() (localctx IAlter_table_s } { p.SetState(3348) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58504,13 +58504,13 @@ type Table_setting_valueContext struct { func NewEmptyTable_setting_valueContext() *Table_setting_valueContext { var p = new(Table_setting_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_setting_value + p.RuleIndex = YQLParserRULE_table_setting_value return p } func InitEmptyTable_setting_valueContext(p *Table_setting_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_setting_value + p.RuleIndex = YQLParserRULE_table_setting_value } func (*Table_setting_valueContext) IsTable_setting_valueContext() {} @@ -58521,7 +58521,7 @@ func NewTable_setting_valueContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_setting_value + p.RuleIndex = YQLParserRULE_table_setting_value return p } @@ -58545,7 +58545,7 @@ func (s *Table_setting_valueContext) Id() IIdContext { } func (s *Table_setting_valueContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Table_setting_valueContext) Integer() IIntegerContext { @@ -58597,7 +58597,7 @@ func (s *Table_setting_valueContext) Ttl_tier_list() ITtl_tier_listContext { } func (s *Table_setting_valueContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Table_setting_valueContext) An_id() IAn_idContext { @@ -58617,23 +58617,23 @@ func (s *Table_setting_valueContext) An_id() IAn_idContext { } func (s *Table_setting_valueContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Table_setting_valueContext) SECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSECONDS, 0) + return s.GetToken(YQLParserSECONDS, 0) } func (s *Table_setting_valueContext) MILLISECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMILLISECONDS, 0) + return s.GetToken(YQLParserMILLISECONDS, 0) } func (s *Table_setting_valueContext) MICROSECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMICROSECONDS, 0) + return s.GetToken(YQLParserMICROSECONDS, 0) } func (s *Table_setting_valueContext) NANOSECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNANOSECONDS, 0) + return s.GetToken(YQLParserNANOSECONDS, 0) } func (s *Table_setting_valueContext) Bool_value() IBool_valueContext { @@ -58662,13 +58662,13 @@ func (s *Table_setting_valueContext) ToStringTree(ruleNames []string, recog antl func (s *Table_setting_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_setting_value(s) } } func (s *Table_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_setting_value(s) } } @@ -58676,9 +58676,9 @@ func (s *Table_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Table_setting_value() (localctx ITable_setting_valueContext) { +func (p *YQLParser) Table_setting_value() (localctx ITable_setting_valueContext) { localctx = NewTable_setting_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 546, YQLv1Antlr4ParserRULE_table_setting_value) + p.EnterRule(localctx, 546, YQLParserRULE_table_setting_value) var _la int p.SetState(3363) @@ -58700,7 +58700,7 @@ func (p *YQLv1Antlr4Parser) Table_setting_value() (localctx ITable_setting_value p.EnterOuterAlt(localctx, 2) { p.SetState(3352) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58732,7 +58732,7 @@ func (p *YQLv1Antlr4Parser) Table_setting_value() (localctx ITable_setting_value } { p.SetState(3356) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58750,10 +58750,10 @@ func (p *YQLv1Antlr4Parser) Table_setting_value() (localctx ITable_setting_value _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserAS { + if _la == YQLParserAS { { p.SetState(3358) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58763,7 +58763,7 @@ func (p *YQLv1Antlr4Parser) Table_setting_value() (localctx ITable_setting_value p.SetState(3359) _la = p.GetTokenStream().LA(1) - if !(((int64((_la - 190)) & ^0x3f) == 0 && ((int64(1) << (_la - 190)) & 11) != 0) || _la == YQLv1Antlr4ParserSECONDS) { + if !(((int64((_la - 190)) & ^0x3f) == 0 && ((int64(1) << (_la - 190)) & 11) != 0) || _la == YQLParserSECONDS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -58827,13 +58827,13 @@ type Ttl_tier_listContext struct { func NewEmptyTtl_tier_listContext() *Ttl_tier_listContext { var p = new(Ttl_tier_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ttl_tier_list + p.RuleIndex = YQLParserRULE_ttl_tier_list return p } func InitEmptyTtl_tier_listContext(p *Ttl_tier_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ttl_tier_list + p.RuleIndex = YQLParserRULE_ttl_tier_list } func (*Ttl_tier_listContext) IsTtl_tier_listContext() {} @@ -58844,7 +58844,7 @@ func NewTtl_tier_listContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_ttl_tier_list + p.RuleIndex = YQLParserRULE_ttl_tier_list return p } @@ -58934,11 +58934,11 @@ func (s *Ttl_tier_listContext) Ttl_tier_action(i int) ITtl_tier_actionContext { } func (s *Ttl_tier_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Ttl_tier_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Ttl_tier_listContext) GetRuleContext() antlr.RuleContext { @@ -58951,13 +58951,13 @@ func (s *Ttl_tier_listContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Ttl_tier_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTtl_tier_list(s) } } func (s *Ttl_tier_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTtl_tier_list(s) } } @@ -58965,9 +58965,9 @@ func (s *Ttl_tier_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Ttl_tier_list() (localctx ITtl_tier_listContext) { +func (p *YQLParser) Ttl_tier_list() (localctx ITtl_tier_listContext) { localctx = NewTtl_tier_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 548, YQLv1Antlr4ParserRULE_ttl_tier_list) + p.EnterRule(localctx, 548, YQLParserRULE_ttl_tier_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -58983,7 +58983,7 @@ func (p *YQLv1Antlr4Parser) Ttl_tier_list() (localctx ITtl_tier_listContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDELETE || _la == YQLv1Antlr4ParserTO { + if _la == YQLParserDELETE || _la == YQLParserTO { { p.SetState(3366) p.Ttl_tier_action() @@ -58996,10 +58996,10 @@ func (p *YQLv1Antlr4Parser) Ttl_tier_list() (localctx ITtl_tier_listContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3367) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59068,13 +59068,13 @@ type Ttl_tier_actionContext struct { func NewEmptyTtl_tier_actionContext() *Ttl_tier_actionContext { var p = new(Ttl_tier_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ttl_tier_action + p.RuleIndex = YQLParserRULE_ttl_tier_action return p } func InitEmptyTtl_tier_actionContext(p *Ttl_tier_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_ttl_tier_action + p.RuleIndex = YQLParserRULE_ttl_tier_action } func (*Ttl_tier_actionContext) IsTtl_tier_actionContext() {} @@ -59085,7 +59085,7 @@ func NewTtl_tier_actionContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_ttl_tier_action + p.RuleIndex = YQLParserRULE_ttl_tier_action return p } @@ -59093,19 +59093,19 @@ func NewTtl_tier_actionContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Ttl_tier_actionContext) GetParser() antlr.Parser { return s.parser } func (s *Ttl_tier_actionContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Ttl_tier_actionContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Ttl_tier_actionContext) DATA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATA, 0) + return s.GetToken(YQLParserDATA, 0) } func (s *Ttl_tier_actionContext) SOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSOURCE, 0) + return s.GetToken(YQLParserSOURCE, 0) } func (s *Ttl_tier_actionContext) An_id() IAn_idContext { @@ -59125,7 +59125,7 @@ func (s *Ttl_tier_actionContext) An_id() IAn_idContext { } func (s *Ttl_tier_actionContext) DELETE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDELETE, 0) + return s.GetToken(YQLParserDELETE, 0) } func (s *Ttl_tier_actionContext) GetRuleContext() antlr.RuleContext { @@ -59138,13 +59138,13 @@ func (s *Ttl_tier_actionContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Ttl_tier_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTtl_tier_action(s) } } func (s *Ttl_tier_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTtl_tier_action(s) } } @@ -59152,9 +59152,9 @@ func (s *Ttl_tier_actionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Ttl_tier_action() (localctx ITtl_tier_actionContext) { +func (p *YQLParser) Ttl_tier_action() (localctx ITtl_tier_actionContext) { localctx = NewTtl_tier_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 550, YQLv1Antlr4ParserRULE_ttl_tier_action) + p.EnterRule(localctx, 550, YQLParserRULE_ttl_tier_action) p.SetState(3384) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -59162,11 +59162,11 @@ func (p *YQLv1Antlr4Parser) Ttl_tier_action() (localctx ITtl_tier_actionContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserTO: + case YQLParserTO: p.EnterOuterAlt(localctx, 1) { p.SetState(3378) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59174,7 +59174,7 @@ func (p *YQLv1Antlr4Parser) Ttl_tier_action() (localctx ITtl_tier_actionContext) } { p.SetState(3379) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59182,7 +59182,7 @@ func (p *YQLv1Antlr4Parser) Ttl_tier_action() (localctx ITtl_tier_actionContext) } { p.SetState(3380) - p.Match(YQLv1Antlr4ParserDATA) + p.Match(YQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59190,7 +59190,7 @@ func (p *YQLv1Antlr4Parser) Ttl_tier_action() (localctx ITtl_tier_actionContext) } { p.SetState(3381) - p.Match(YQLv1Antlr4ParserSOURCE) + p.Match(YQLParserSOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59202,11 +59202,11 @@ func (p *YQLv1Antlr4Parser) Ttl_tier_action() (localctx ITtl_tier_actionContext) } - case YQLv1Antlr4ParserDELETE: + case YQLParserDELETE: p.EnterOuterAlt(localctx, 2) { p.SetState(3383) - p.Match(YQLv1Antlr4ParserDELETE) + p.Match(YQLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59259,13 +59259,13 @@ type Family_entryContext struct { func NewEmptyFamily_entryContext() *Family_entryContext { var p = new(Family_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_entry + p.RuleIndex = YQLParserRULE_family_entry return p } func InitEmptyFamily_entryContext(p *Family_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_entry + p.RuleIndex = YQLParserRULE_family_entry } func (*Family_entryContext) IsFamily_entryContext() {} @@ -59276,7 +59276,7 @@ func NewFamily_entryContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_family_entry + p.RuleIndex = YQLParserRULE_family_entry return p } @@ -59284,7 +59284,7 @@ func NewFamily_entryContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Family_entryContext) GetParser() antlr.Parser { return s.parser } func (s *Family_entryContext) FAMILY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFAMILY, 0) + return s.GetToken(YQLParserFAMILY, 0) } func (s *Family_entryContext) An_id() IAn_idContext { @@ -59329,13 +59329,13 @@ func (s *Family_entryContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Family_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFamily_entry(s) } } func (s *Family_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFamily_entry(s) } } @@ -59343,13 +59343,13 @@ func (s *Family_entryContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Family_entry() (localctx IFamily_entryContext) { +func (p *YQLParser) Family_entry() (localctx IFamily_entryContext) { localctx = NewFamily_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 552, YQLv1Antlr4ParserRULE_family_entry) + p.EnterRule(localctx, 552, YQLParserRULE_family_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(3386) - p.Match(YQLv1Antlr4ParserFAMILY) + p.Match(YQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59407,13 +59407,13 @@ type Family_settingsContext struct { func NewEmptyFamily_settingsContext() *Family_settingsContext { var p = new(Family_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_settings + p.RuleIndex = YQLParserRULE_family_settings return p } func InitEmptyFamily_settingsContext(p *Family_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_settings + p.RuleIndex = YQLParserRULE_family_settings } func (*Family_settingsContext) IsFamily_settingsContext() {} @@ -59424,7 +59424,7 @@ func NewFamily_settingsContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_family_settings + p.RuleIndex = YQLParserRULE_family_settings return p } @@ -59432,11 +59432,11 @@ func NewFamily_settingsContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Family_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *Family_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Family_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Family_settingsContext) AllFamily_settings_entry() []IFamily_settings_entryContext { @@ -59481,11 +59481,11 @@ func (s *Family_settingsContext) Family_settings_entry(i int) IFamily_settings_e } func (s *Family_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Family_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Family_settingsContext) GetRuleContext() antlr.RuleContext { @@ -59498,13 +59498,13 @@ func (s *Family_settingsContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Family_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFamily_settings(s) } } func (s *Family_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFamily_settings(s) } } @@ -59512,15 +59512,15 @@ func (s *Family_settingsContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Family_settings() (localctx IFamily_settingsContext) { +func (p *YQLParser) Family_settings() (localctx IFamily_settingsContext) { localctx = NewFamily_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 554, YQLv1Antlr4ParserRULE_family_settings) + p.EnterRule(localctx, 554, YQLParserRULE_family_settings) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3390) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59547,10 +59547,10 @@ func (p *YQLv1Antlr4Parser) Family_settings() (localctx IFamily_settingsContext) _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3392) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59573,7 +59573,7 @@ func (p *YQLv1Antlr4Parser) Family_settings() (localctx IFamily_settingsContext) } { p.SetState(3401) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59620,13 +59620,13 @@ type Family_settings_entryContext struct { func NewEmptyFamily_settings_entryContext() *Family_settings_entryContext { var p = new(Family_settings_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_settings_entry + p.RuleIndex = YQLParserRULE_family_settings_entry return p } func InitEmptyFamily_settings_entryContext(p *Family_settings_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_settings_entry + p.RuleIndex = YQLParserRULE_family_settings_entry } func (*Family_settings_entryContext) IsFamily_settings_entryContext() {} @@ -59637,7 +59637,7 @@ func NewFamily_settings_entryContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_family_settings_entry + p.RuleIndex = YQLParserRULE_family_settings_entry return p } @@ -59661,7 +59661,7 @@ func (s *Family_settings_entryContext) An_id() IAn_idContext { } func (s *Family_settings_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Family_settings_entryContext) Family_setting_value() IFamily_setting_valueContext { @@ -59690,13 +59690,13 @@ func (s *Family_settings_entryContext) ToStringTree(ruleNames []string, recog an func (s *Family_settings_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFamily_settings_entry(s) } } func (s *Family_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFamily_settings_entry(s) } } @@ -59704,9 +59704,9 @@ func (s *Family_settings_entryContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Family_settings_entry() (localctx IFamily_settings_entryContext) { +func (p *YQLParser) Family_settings_entry() (localctx IFamily_settings_entryContext) { localctx = NewFamily_settings_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 556, YQLv1Antlr4ParserRULE_family_settings_entry) + p.EnterRule(localctx, 556, YQLParserRULE_family_settings_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(3403) @@ -59714,7 +59714,7 @@ func (p *YQLv1Antlr4Parser) Family_settings_entry() (localctx IFamily_settings_e } { p.SetState(3404) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59764,13 +59764,13 @@ type Family_setting_valueContext struct { func NewEmptyFamily_setting_valueContext() *Family_setting_valueContext { var p = new(Family_setting_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_setting_value + p.RuleIndex = YQLParserRULE_family_setting_value return p } func InitEmptyFamily_setting_valueContext(p *Family_setting_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_family_setting_value + p.RuleIndex = YQLParserRULE_family_setting_value } func (*Family_setting_valueContext) IsFamily_setting_valueContext() {} @@ -59781,7 +59781,7 @@ func NewFamily_setting_valueContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_family_setting_value + p.RuleIndex = YQLParserRULE_family_setting_value return p } @@ -59789,7 +59789,7 @@ func NewFamily_setting_valueContext(parser antlr.Parser, parent antlr.ParserRule func (s *Family_setting_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Family_setting_valueContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Family_setting_valueContext) Integer() IIntegerContext { @@ -59818,13 +59818,13 @@ func (s *Family_setting_valueContext) ToStringTree(ruleNames []string, recog ant func (s *Family_setting_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFamily_setting_value(s) } } func (s *Family_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFamily_setting_value(s) } } @@ -59832,9 +59832,9 @@ func (s *Family_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Family_setting_value() (localctx IFamily_setting_valueContext) { +func (p *YQLParser) Family_setting_value() (localctx IFamily_setting_valueContext) { localctx = NewFamily_setting_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 558, YQLv1Antlr4ParserRULE_family_setting_value) + p.EnterRule(localctx, 558, YQLParserRULE_family_setting_value) p.SetState(3409) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -59842,11 +59842,11 @@ func (p *YQLv1Antlr4Parser) Family_setting_value() (localctx IFamily_setting_val } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 1) { p.SetState(3407) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59854,7 +59854,7 @@ func (p *YQLv1Antlr4Parser) Family_setting_value() (localctx IFamily_setting_val } - case YQLv1Antlr4ParserDIGITS, YQLv1Antlr4ParserINTEGER_VALUE: + case YQLParserDIGITS, YQLParserINTEGER_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(3408) @@ -59910,13 +59910,13 @@ type Split_boundariesContext struct { func NewEmptySplit_boundariesContext() *Split_boundariesContext { var p = new(Split_boundariesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_split_boundaries + p.RuleIndex = YQLParserRULE_split_boundaries return p } func InitEmptySplit_boundariesContext(p *Split_boundariesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_split_boundaries + p.RuleIndex = YQLParserRULE_split_boundaries } func (*Split_boundariesContext) IsSplit_boundariesContext() {} @@ -59927,7 +59927,7 @@ func NewSplit_boundariesContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_split_boundaries + p.RuleIndex = YQLParserRULE_split_boundaries return p } @@ -59935,7 +59935,7 @@ func NewSplit_boundariesContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Split_boundariesContext) GetParser() antlr.Parser { return s.parser } func (s *Split_boundariesContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Split_boundariesContext) AllLiteral_value_list() []ILiteral_value_listContext { @@ -59980,15 +59980,15 @@ func (s *Split_boundariesContext) Literal_value_list(i int) ILiteral_value_listC } func (s *Split_boundariesContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Split_boundariesContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Split_boundariesContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Split_boundariesContext) GetRuleContext() antlr.RuleContext { @@ -60001,13 +60001,13 @@ func (s *Split_boundariesContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Split_boundariesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSplit_boundaries(s) } } func (s *Split_boundariesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSplit_boundaries(s) } } @@ -60015,9 +60015,9 @@ func (s *Split_boundariesContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Split_boundaries() (localctx ISplit_boundariesContext) { +func (p *YQLParser) Split_boundaries() (localctx ISplit_boundariesContext) { localctx = NewSplit_boundariesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 560, YQLv1Antlr4ParserRULE_split_boundaries) + p.EnterRule(localctx, 560, YQLParserRULE_split_boundaries) var _la int p.SetState(3423) @@ -60031,7 +60031,7 @@ func (p *YQLv1Antlr4Parser) Split_boundaries() (localctx ISplit_boundariesContex p.EnterOuterAlt(localctx, 1) { p.SetState(3411) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60049,10 +60049,10 @@ func (p *YQLv1Antlr4Parser) Split_boundaries() (localctx ISplit_boundariesContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3413) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60073,7 +60073,7 @@ func (p *YQLv1Antlr4Parser) Split_boundaries() (localctx ISplit_boundariesContex } { p.SetState(3420) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60134,13 +60134,13 @@ type Literal_value_listContext struct { func NewEmptyLiteral_value_listContext() *Literal_value_listContext { var p = new(Literal_value_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_literal_value_list + p.RuleIndex = YQLParserRULE_literal_value_list return p } func InitEmptyLiteral_value_listContext(p *Literal_value_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_literal_value_list + p.RuleIndex = YQLParserRULE_literal_value_list } func (*Literal_value_listContext) IsLiteral_value_listContext() {} @@ -60151,7 +60151,7 @@ func NewLiteral_value_listContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_literal_value_list + p.RuleIndex = YQLParserRULE_literal_value_list return p } @@ -60159,7 +60159,7 @@ func NewLiteral_value_listContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Literal_value_listContext) GetParser() antlr.Parser { return s.parser } func (s *Literal_value_listContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Literal_value_listContext) AllLiteral_value() []ILiteral_valueContext { @@ -60204,15 +60204,15 @@ func (s *Literal_value_listContext) Literal_value(i int) ILiteral_valueContext { } func (s *Literal_value_listContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Literal_value_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Literal_value_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Literal_value_listContext) GetRuleContext() antlr.RuleContext { @@ -60225,13 +60225,13 @@ func (s *Literal_value_listContext) ToStringTree(ruleNames []string, recog antlr func (s *Literal_value_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterLiteral_value_list(s) } } func (s *Literal_value_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitLiteral_value_list(s) } } @@ -60239,15 +60239,15 @@ func (s *Literal_value_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Literal_value_list() (localctx ILiteral_value_listContext) { +func (p *YQLParser) Literal_value_list() (localctx ILiteral_value_listContext) { localctx = NewLiteral_value_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 562, YQLv1Antlr4ParserRULE_literal_value_list) + p.EnterRule(localctx, 562, YQLParserRULE_literal_value_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3425) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60265,10 +60265,10 @@ func (p *YQLv1Antlr4Parser) Literal_value_list() (localctx ILiteral_value_listCo _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3427) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60289,7 +60289,7 @@ func (p *YQLv1Antlr4Parser) Literal_value_list() (localctx ILiteral_value_listCo } { p.SetState(3434) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60336,13 +60336,13 @@ type Alter_table_alter_index_actionContext struct { func NewEmptyAlter_table_alter_index_actionContext() *Alter_table_alter_index_actionContext { var p = new(Alter_table_alter_index_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_index_action + p.RuleIndex = YQLParserRULE_alter_table_alter_index_action return p } func InitEmptyAlter_table_alter_index_actionContext(p *Alter_table_alter_index_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_index_action + p.RuleIndex = YQLParserRULE_alter_table_alter_index_action } func (*Alter_table_alter_index_actionContext) IsAlter_table_alter_index_actionContext() {} @@ -60353,7 +60353,7 @@ func NewAlter_table_alter_index_actionContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_table_alter_index_action + p.RuleIndex = YQLParserRULE_alter_table_alter_index_action return p } @@ -60418,13 +60418,13 @@ func (s *Alter_table_alter_index_actionContext) ToStringTree(ruleNames []string, func (s *Alter_table_alter_index_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_table_alter_index_action(s) } } func (s *Alter_table_alter_index_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_table_alter_index_action(s) } } @@ -60432,9 +60432,9 @@ func (s *Alter_table_alter_index_actionContext) ExitRule(listener antlr.ParseTre -func (p *YQLv1Antlr4Parser) Alter_table_alter_index_action() (localctx IAlter_table_alter_index_actionContext) { +func (p *YQLParser) Alter_table_alter_index_action() (localctx IAlter_table_alter_index_actionContext) { localctx = NewAlter_table_alter_index_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 564, YQLv1Antlr4ParserRULE_alter_table_alter_index_action) + p.EnterRule(localctx, 564, YQLParserRULE_alter_table_alter_index_action) p.SetState(3439) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -60512,13 +60512,13 @@ type Drop_table_stmtContext struct { func NewEmptyDrop_table_stmtContext() *Drop_table_stmtContext { var p = new(Drop_table_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_table_stmt + p.RuleIndex = YQLParserRULE_drop_table_stmt return p } func InitEmptyDrop_table_stmtContext(p *Drop_table_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_table_stmt + p.RuleIndex = YQLParserRULE_drop_table_stmt } func (*Drop_table_stmtContext) IsDrop_table_stmtContext() {} @@ -60529,7 +60529,7 @@ func NewDrop_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_table_stmt + p.RuleIndex = YQLParserRULE_drop_table_stmt return p } @@ -60537,7 +60537,7 @@ func NewDrop_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Drop_table_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_table_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_table_stmtContext) Simple_table_ref() ISimple_table_refContext { @@ -60557,23 +60557,23 @@ func (s *Drop_table_stmtContext) Simple_table_ref() ISimple_table_refContext { } func (s *Drop_table_stmtContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Drop_table_stmtContext) TABLESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESTORE, 0) + return s.GetToken(YQLParserTABLESTORE, 0) } func (s *Drop_table_stmtContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Drop_table_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Drop_table_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Drop_table_stmtContext) GetRuleContext() antlr.RuleContext { @@ -60586,13 +60586,13 @@ func (s *Drop_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Drop_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_table_stmt(s) } } func (s *Drop_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_table_stmt(s) } } @@ -60600,13 +60600,13 @@ func (s *Drop_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Drop_table_stmt() (localctx IDrop_table_stmtContext) { +func (p *YQLParser) Drop_table_stmt() (localctx IDrop_table_stmtContext) { localctx = NewDrop_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 566, YQLv1Antlr4ParserRULE_drop_table_stmt) + p.EnterRule(localctx, 566, YQLParserRULE_drop_table_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3441) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60619,10 +60619,10 @@ func (p *YQLv1Antlr4Parser) Drop_table_stmt() (localctx IDrop_table_stmtContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserTABLE: + case YQLParserTABLE: { p.SetState(3442) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60630,10 +60630,10 @@ func (p *YQLv1Antlr4Parser) Drop_table_stmt() (localctx IDrop_table_stmtContext) } - case YQLv1Antlr4ParserTABLESTORE: + case YQLParserTABLESTORE: { p.SetState(3443) - p.Match(YQLv1Antlr4ParserTABLESTORE) + p.Match(YQLParserTABLESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60641,10 +60641,10 @@ func (p *YQLv1Antlr4Parser) Drop_table_stmt() (localctx IDrop_table_stmtContext) } - case YQLv1Antlr4ParserEXTERNAL: + case YQLParserEXTERNAL: { p.SetState(3444) - p.Match(YQLv1Antlr4ParserEXTERNAL) + p.Match(YQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60652,7 +60652,7 @@ func (p *YQLv1Antlr4Parser) Drop_table_stmt() (localctx IDrop_table_stmtContext) } { p.SetState(3445) - p.Match(YQLv1Antlr4ParserTABLE) + p.Match(YQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60672,7 +60672,7 @@ func (p *YQLv1Antlr4Parser) Drop_table_stmt() (localctx IDrop_table_stmtContext) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 345, p.GetParserRuleContext()) == 1 { { p.SetState(3448) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60680,7 +60680,7 @@ func (p *YQLv1Antlr4Parser) Drop_table_stmt() (localctx IDrop_table_stmtContext) } { p.SetState(3449) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60737,13 +60737,13 @@ type Create_user_stmtContext struct { func NewEmptyCreate_user_stmtContext() *Create_user_stmtContext { var p = new(Create_user_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_user_stmt + p.RuleIndex = YQLParserRULE_create_user_stmt return p } func InitEmptyCreate_user_stmtContext(p *Create_user_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_user_stmt + p.RuleIndex = YQLParserRULE_create_user_stmt } func (*Create_user_stmtContext) IsCreate_user_stmtContext() {} @@ -60754,7 +60754,7 @@ func NewCreate_user_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_user_stmt + p.RuleIndex = YQLParserRULE_create_user_stmt return p } @@ -60762,11 +60762,11 @@ func NewCreate_user_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Create_user_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_user_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_user_stmtContext) USER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSER, 0) + return s.GetToken(YQLParserUSER, 0) } func (s *Create_user_stmtContext) Role_name() IRole_nameContext { @@ -60836,13 +60836,13 @@ func (s *Create_user_stmtContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Create_user_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_user_stmt(s) } } func (s *Create_user_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_user_stmt(s) } } @@ -60850,15 +60850,15 @@ func (s *Create_user_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_user_stmt() (localctx ICreate_user_stmtContext) { +func (p *YQLParser) Create_user_stmt() (localctx ICreate_user_stmtContext) { localctx = NewCreate_user_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 568, YQLv1Antlr4ParserRULE_create_user_stmt) + p.EnterRule(localctx, 568, YQLParserRULE_create_user_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3454) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60866,7 +60866,7 @@ func (p *YQLv1Antlr4Parser) Create_user_stmt() (localctx ICreate_user_stmtContex } { p.SetState(3455) - p.Match(YQLv1Antlr4ParserUSER) + p.Match(YQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60884,7 +60884,7 @@ func (p *YQLv1Antlr4Parser) Create_user_stmt() (localctx ICreate_user_stmtContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserENCRYPTED || ((int64((_la - 184)) & ^0x3f) == 0 && ((int64(1) << (_la - 184)) & 34359746561) != 0) { + for _la == YQLParserENCRYPTED || ((int64((_la - 184)) & ^0x3f) == 0 && ((int64(1) << (_la - 184)) & 34359746561) != 0) { { p.SetState(3457) p.Create_user_option() @@ -60945,13 +60945,13 @@ type Alter_user_stmtContext struct { func NewEmptyAlter_user_stmtContext() *Alter_user_stmtContext { var p = new(Alter_user_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_user_stmt + p.RuleIndex = YQLParserRULE_alter_user_stmt return p } func InitEmptyAlter_user_stmtContext(p *Alter_user_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_user_stmt + p.RuleIndex = YQLParserRULE_alter_user_stmt } func (*Alter_user_stmtContext) IsAlter_user_stmtContext() {} @@ -60962,7 +60962,7 @@ func NewAlter_user_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_user_stmt + p.RuleIndex = YQLParserRULE_alter_user_stmt return p } @@ -60970,11 +60970,11 @@ func NewAlter_user_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Alter_user_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_user_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_user_stmtContext) USER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSER, 0) + return s.GetToken(YQLParserUSER, 0) } func (s *Alter_user_stmtContext) AllRole_name() []IRole_nameContext { @@ -61019,15 +61019,15 @@ func (s *Alter_user_stmtContext) Role_name(i int) IRole_nameContext { } func (s *Alter_user_stmtContext) RENAME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRENAME, 0) + return s.GetToken(YQLParserRENAME, 0) } func (s *Alter_user_stmtContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Alter_user_stmtContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Alter_user_stmtContext) AllCreate_user_option() []ICreate_user_optionContext { @@ -61081,13 +61081,13 @@ func (s *Alter_user_stmtContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Alter_user_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_user_stmt(s) } } func (s *Alter_user_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_user_stmt(s) } } @@ -61095,15 +61095,15 @@ func (s *Alter_user_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Alter_user_stmt() (localctx IAlter_user_stmtContext) { +func (p *YQLParser) Alter_user_stmt() (localctx IAlter_user_stmtContext) { localctx = NewAlter_user_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 570, YQLv1Antlr4ParserRULE_alter_user_stmt) + p.EnterRule(localctx, 570, YQLParserRULE_alter_user_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3463) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61111,7 +61111,7 @@ func (p *YQLv1Antlr4Parser) Alter_user_stmt() (localctx IAlter_user_stmtContext) } { p.SetState(3464) - p.Match(YQLv1Antlr4ParserUSER) + p.Match(YQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61128,7 +61128,7 @@ func (p *YQLv1Antlr4Parser) Alter_user_stmt() (localctx IAlter_user_stmtContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserWITH: + case YQLParserENCRYPTED, YQLParserLOGIN, YQLParserNOLOGIN, YQLParserPASSWORD, YQLParserWITH: p.SetState(3467) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -61137,10 +61137,10 @@ func (p *YQLv1Antlr4Parser) Alter_user_stmt() (localctx IAlter_user_stmtContext) _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(3466) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61156,7 +61156,7 @@ func (p *YQLv1Antlr4Parser) Alter_user_stmt() (localctx IAlter_user_stmtContext) _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == YQLv1Antlr4ParserENCRYPTED || ((int64((_la - 184)) & ^0x3f) == 0 && ((int64(1) << (_la - 184)) & 34359746561) != 0) { + for ok := true; ok; ok = _la == YQLParserENCRYPTED || ((int64((_la - 184)) & ^0x3f) == 0 && ((int64(1) << (_la - 184)) & 34359746561) != 0) { { p.SetState(3469) p.Create_user_option() @@ -61172,10 +61172,10 @@ func (p *YQLv1Antlr4Parser) Alter_user_stmt() (localctx IAlter_user_stmtContext) } - case YQLv1Antlr4ParserRENAME: + case YQLParserRENAME: { p.SetState(3474) - p.Match(YQLv1Antlr4ParserRENAME) + p.Match(YQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61183,7 +61183,7 @@ func (p *YQLv1Antlr4Parser) Alter_user_stmt() (localctx IAlter_user_stmtContext) } { p.SetState(3475) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61246,13 +61246,13 @@ type Create_group_stmtContext struct { func NewEmptyCreate_group_stmtContext() *Create_group_stmtContext { var p = new(Create_group_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_group_stmt + p.RuleIndex = YQLParserRULE_create_group_stmt return p } func InitEmptyCreate_group_stmtContext(p *Create_group_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_group_stmt + p.RuleIndex = YQLParserRULE_create_group_stmt } func (*Create_group_stmtContext) IsCreate_group_stmtContext() {} @@ -61263,7 +61263,7 @@ func NewCreate_group_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_group_stmt + p.RuleIndex = YQLParserRULE_create_group_stmt return p } @@ -61271,11 +61271,11 @@ func NewCreate_group_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Create_group_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_group_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_group_stmtContext) GROUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUP, 0) + return s.GetToken(YQLParserGROUP, 0) } func (s *Create_group_stmtContext) AllRole_name() []IRole_nameContext { @@ -61320,19 +61320,19 @@ func (s *Create_group_stmtContext) Role_name(i int) IRole_nameContext { } func (s *Create_group_stmtContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Create_group_stmtContext) USER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSER, 0) + return s.GetToken(YQLParserUSER, 0) } func (s *Create_group_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Create_group_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Create_group_stmtContext) GetRuleContext() antlr.RuleContext { @@ -61345,13 +61345,13 @@ func (s *Create_group_stmtContext) ToStringTree(ruleNames []string, recog antlr. func (s *Create_group_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_group_stmt(s) } } func (s *Create_group_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_group_stmt(s) } } @@ -61359,9 +61359,9 @@ func (s *Create_group_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_group_stmt() (localctx ICreate_group_stmtContext) { +func (p *YQLParser) Create_group_stmt() (localctx ICreate_group_stmtContext) { localctx = NewCreate_group_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 572, YQLv1Antlr4ParserRULE_create_group_stmt) + p.EnterRule(localctx, 572, YQLParserRULE_create_group_stmt) var _la int var _alt int @@ -61369,7 +61369,7 @@ func (p *YQLv1Antlr4Parser) Create_group_stmt() (localctx ICreate_group_stmtCont p.EnterOuterAlt(localctx, 1) { p.SetState(3479) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61377,7 +61377,7 @@ func (p *YQLv1Antlr4Parser) Create_group_stmt() (localctx ICreate_group_stmtCont } { p.SetState(3480) - p.Match(YQLv1Antlr4ParserGROUP) + p.Match(YQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61395,10 +61395,10 @@ func (p *YQLv1Antlr4Parser) Create_group_stmt() (localctx ICreate_group_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(3482) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61406,7 +61406,7 @@ func (p *YQLv1Antlr4Parser) Create_group_stmt() (localctx ICreate_group_stmtCont } { p.SetState(3483) - p.Match(YQLv1Antlr4ParserUSER) + p.Match(YQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61429,7 +61429,7 @@ func (p *YQLv1Antlr4Parser) Create_group_stmt() (localctx ICreate_group_stmtCont if _alt == 1 { { p.SetState(3485) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61460,10 +61460,10 @@ func (p *YQLv1Antlr4Parser) Create_group_stmt() (localctx ICreate_group_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3492) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61522,13 +61522,13 @@ type Alter_group_stmtContext struct { func NewEmptyAlter_group_stmtContext() *Alter_group_stmtContext { var p = new(Alter_group_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_group_stmt + p.RuleIndex = YQLParserRULE_alter_group_stmt return p } func InitEmptyAlter_group_stmtContext(p *Alter_group_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_group_stmt + p.RuleIndex = YQLParserRULE_alter_group_stmt } func (*Alter_group_stmtContext) IsAlter_group_stmtContext() {} @@ -61539,7 +61539,7 @@ func NewAlter_group_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_group_stmt + p.RuleIndex = YQLParserRULE_alter_group_stmt return p } @@ -61547,11 +61547,11 @@ func NewAlter_group_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Alter_group_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_group_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_group_stmtContext) GROUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUP, 0) + return s.GetToken(YQLParserGROUP, 0) } func (s *Alter_group_stmtContext) AllRole_name() []IRole_nameContext { @@ -61596,31 +61596,31 @@ func (s *Alter_group_stmtContext) Role_name(i int) IRole_nameContext { } func (s *Alter_group_stmtContext) USER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSER, 0) + return s.GetToken(YQLParserUSER, 0) } func (s *Alter_group_stmtContext) RENAME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRENAME, 0) + return s.GetToken(YQLParserRENAME, 0) } func (s *Alter_group_stmtContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Alter_group_stmtContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Alter_group_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Alter_group_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_group_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_group_stmtContext) GetRuleContext() antlr.RuleContext { @@ -61633,13 +61633,13 @@ func (s *Alter_group_stmtContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Alter_group_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_group_stmt(s) } } func (s *Alter_group_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_group_stmt(s) } } @@ -61647,9 +61647,9 @@ func (s *Alter_group_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContext) { +func (p *YQLParser) Alter_group_stmt() (localctx IAlter_group_stmtContext) { localctx = NewAlter_group_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 574, YQLv1Antlr4ParserRULE_alter_group_stmt) + p.EnterRule(localctx, 574, YQLParserRULE_alter_group_stmt) var _la int var _alt int @@ -61657,7 +61657,7 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex p.EnterOuterAlt(localctx, 1) { p.SetState(3497) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61665,7 +61665,7 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex } { p.SetState(3498) - p.Match(YQLv1Antlr4ParserGROUP) + p.Match(YQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61682,12 +61682,12 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserADD, YQLv1Antlr4ParserDROP: + case YQLParserADD, YQLParserDROP: { p.SetState(3500) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserADD || _la == YQLv1Antlr4ParserDROP) { + if !(_la == YQLParserADD || _la == YQLParserDROP) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -61696,7 +61696,7 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex } { p.SetState(3501) - p.Match(YQLv1Antlr4ParserUSER) + p.Match(YQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61719,7 +61719,7 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex if _alt == 1 { { p.SetState(3503) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61750,10 +61750,10 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3510) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61763,10 +61763,10 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex } - case YQLv1Antlr4ParserRENAME: + case YQLParserRENAME: { p.SetState(3513) - p.Match(YQLv1Antlr4ParserRENAME) + p.Match(YQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61774,7 +61774,7 @@ func (p *YQLv1Antlr4Parser) Alter_group_stmt() (localctx IAlter_group_stmtContex } { p.SetState(3514) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61838,13 +61838,13 @@ type Drop_role_stmtContext struct { func NewEmptyDrop_role_stmtContext() *Drop_role_stmtContext { var p = new(Drop_role_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_role_stmt + p.RuleIndex = YQLParserRULE_drop_role_stmt return p } func InitEmptyDrop_role_stmtContext(p *Drop_role_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_role_stmt + p.RuleIndex = YQLParserRULE_drop_role_stmt } func (*Drop_role_stmtContext) IsDrop_role_stmtContext() {} @@ -61855,7 +61855,7 @@ func NewDrop_role_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_role_stmt + p.RuleIndex = YQLParserRULE_drop_role_stmt return p } @@ -61863,7 +61863,7 @@ func NewDrop_role_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Drop_role_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_role_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_role_stmtContext) AllRole_name() []IRole_nameContext { @@ -61908,27 +61908,27 @@ func (s *Drop_role_stmtContext) Role_name(i int) IRole_nameContext { } func (s *Drop_role_stmtContext) USER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSER, 0) + return s.GetToken(YQLParserUSER, 0) } func (s *Drop_role_stmtContext) GROUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUP, 0) + return s.GetToken(YQLParserGROUP, 0) } func (s *Drop_role_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Drop_role_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Drop_role_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Drop_role_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Drop_role_stmtContext) GetRuleContext() antlr.RuleContext { @@ -61941,13 +61941,13 @@ func (s *Drop_role_stmtContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Drop_role_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_role_stmt(s) } } func (s *Drop_role_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_role_stmt(s) } } @@ -61955,9 +61955,9 @@ func (s *Drop_role_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { +func (p *YQLParser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { localctx = NewDrop_role_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 576, YQLv1Antlr4ParserRULE_drop_role_stmt) + p.EnterRule(localctx, 576, YQLParserRULE_drop_role_stmt) var _la int var _alt int @@ -61965,7 +61965,7 @@ func (p *YQLv1Antlr4Parser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(3518) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61975,7 +61975,7 @@ func (p *YQLv1Antlr4Parser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { p.SetState(3519) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserGROUP || _la == YQLv1Antlr4ParserUSER) { + if !(_la == YQLParserGROUP || _la == YQLParserUSER) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -61989,7 +61989,7 @@ func (p *YQLv1Antlr4Parser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 356, p.GetParserRuleContext()) == 1 { { p.SetState(3520) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61997,7 +61997,7 @@ func (p *YQLv1Antlr4Parser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { } { p.SetState(3521) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62024,7 +62024,7 @@ func (p *YQLv1Antlr4Parser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { if _alt == 1 { { p.SetState(3525) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62055,10 +62055,10 @@ func (p *YQLv1Antlr4Parser) Drop_role_stmt() (localctx IDrop_role_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3532) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62106,13 +62106,13 @@ type Role_nameContext struct { func NewEmptyRole_nameContext() *Role_nameContext { var p = new(Role_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_role_name + p.RuleIndex = YQLParserRULE_role_name return p } func InitEmptyRole_nameContext(p *Role_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_role_name + p.RuleIndex = YQLParserRULE_role_name } func (*Role_nameContext) IsRole_nameContext() {} @@ -62123,7 +62123,7 @@ func NewRole_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_role_name + p.RuleIndex = YQLParserRULE_role_name return p } @@ -62172,13 +62172,13 @@ func (s *Role_nameContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Role_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRole_name(s) } } func (s *Role_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRole_name(s) } } @@ -62186,9 +62186,9 @@ func (s *Role_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Role_name() (localctx IRole_nameContext) { +func (p *YQLParser) Role_name() (localctx IRole_nameContext) { localctx = NewRole_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 578, YQLv1Antlr4ParserRULE_role_name) + p.EnterRule(localctx, 578, YQLParserRULE_role_name) p.SetState(3537) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -62196,7 +62196,7 @@ func (p *YQLv1Antlr4Parser) Role_name() (localctx IRole_nameContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(3535) @@ -62204,7 +62204,7 @@ func (p *YQLv1Antlr4Parser) Role_name() (localctx IRole_nameContext) { } - case YQLv1Antlr4ParserDOLLAR: + case YQLParserDOLLAR: p.EnterOuterAlt(localctx, 2) { p.SetState(3536) @@ -62256,13 +62256,13 @@ type Create_user_optionContext struct { func NewEmptyCreate_user_optionContext() *Create_user_optionContext { var p = new(Create_user_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_user_option + p.RuleIndex = YQLParserRULE_create_user_option return p } func InitEmptyCreate_user_optionContext(p *Create_user_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_user_option + p.RuleIndex = YQLParserRULE_create_user_option } func (*Create_user_optionContext) IsCreate_user_optionContext() {} @@ -62273,7 +62273,7 @@ func NewCreate_user_optionContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_user_option + p.RuleIndex = YQLParserRULE_create_user_option return p } @@ -62322,13 +62322,13 @@ func (s *Create_user_optionContext) ToStringTree(ruleNames []string, recog antlr func (s *Create_user_optionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_user_option(s) } } func (s *Create_user_optionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_user_option(s) } } @@ -62336,9 +62336,9 @@ func (s *Create_user_optionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_user_option() (localctx ICreate_user_optionContext) { +func (p *YQLParser) Create_user_option() (localctx ICreate_user_optionContext) { localctx = NewCreate_user_optionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 580, YQLv1Antlr4ParserRULE_create_user_option) + p.EnterRule(localctx, 580, YQLParserRULE_create_user_option) p.SetState(3541) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -62346,7 +62346,7 @@ func (p *YQLv1Antlr4Parser) Create_user_option() (localctx ICreate_user_optionCo } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserPASSWORD: + case YQLParserENCRYPTED, YQLParserPASSWORD: p.EnterOuterAlt(localctx, 1) { p.SetState(3539) @@ -62354,7 +62354,7 @@ func (p *YQLv1Antlr4Parser) Create_user_option() (localctx ICreate_user_optionCo } - case YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserNOLOGIN: + case YQLParserLOGIN, YQLParserNOLOGIN: p.EnterOuterAlt(localctx, 2) { p.SetState(3540) @@ -62407,13 +62407,13 @@ type Password_optionContext struct { func NewEmptyPassword_optionContext() *Password_optionContext { var p = new(Password_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_password_option + p.RuleIndex = YQLParserRULE_password_option return p } func InitEmptyPassword_optionContext(p *Password_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_password_option + p.RuleIndex = YQLParserRULE_password_option } func (*Password_optionContext) IsPassword_optionContext() {} @@ -62424,7 +62424,7 @@ func NewPassword_optionContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_password_option + p.RuleIndex = YQLParserRULE_password_option return p } @@ -62432,7 +62432,7 @@ func NewPassword_optionContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Password_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Password_optionContext) PASSWORD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPASSWORD, 0) + return s.GetToken(YQLParserPASSWORD, 0) } func (s *Password_optionContext) Expr() IExprContext { @@ -62452,7 +62452,7 @@ func (s *Password_optionContext) Expr() IExprContext { } func (s *Password_optionContext) ENCRYPTED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserENCRYPTED, 0) + return s.GetToken(YQLParserENCRYPTED, 0) } func (s *Password_optionContext) GetRuleContext() antlr.RuleContext { @@ -62465,13 +62465,13 @@ func (s *Password_optionContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Password_optionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPassword_option(s) } } func (s *Password_optionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPassword_option(s) } } @@ -62479,9 +62479,9 @@ func (s *Password_optionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Password_option() (localctx IPassword_optionContext) { +func (p *YQLParser) Password_option() (localctx IPassword_optionContext) { localctx = NewPassword_optionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 582, YQLv1Antlr4ParserRULE_password_option) + p.EnterRule(localctx, 582, YQLParserRULE_password_option) var _la int p.EnterOuterAlt(localctx, 1) @@ -62493,10 +62493,10 @@ func (p *YQLv1Antlr4Parser) Password_option() (localctx IPassword_optionContext) _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserENCRYPTED { + if _la == YQLParserENCRYPTED { { p.SetState(3543) - p.Match(YQLv1Antlr4ParserENCRYPTED) + p.Match(YQLParserENCRYPTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62506,7 +62506,7 @@ func (p *YQLv1Antlr4Parser) Password_option() (localctx IPassword_optionContext) } { p.SetState(3546) - p.Match(YQLv1Antlr4ParserPASSWORD) + p.Match(YQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62556,13 +62556,13 @@ type Login_optionContext struct { func NewEmptyLogin_optionContext() *Login_optionContext { var p = new(Login_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_login_option + p.RuleIndex = YQLParserRULE_login_option return p } func InitEmptyLogin_optionContext(p *Login_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_login_option + p.RuleIndex = YQLParserRULE_login_option } func (*Login_optionContext) IsLogin_optionContext() {} @@ -62573,7 +62573,7 @@ func NewLogin_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_login_option + p.RuleIndex = YQLParserRULE_login_option return p } @@ -62581,11 +62581,11 @@ func NewLogin_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Login_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Login_optionContext) LOGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLOGIN, 0) + return s.GetToken(YQLParserLOGIN, 0) } func (s *Login_optionContext) NOLOGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOLOGIN, 0) + return s.GetToken(YQLParserNOLOGIN, 0) } func (s *Login_optionContext) GetRuleContext() antlr.RuleContext { @@ -62598,13 +62598,13 @@ func (s *Login_optionContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Login_optionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterLogin_option(s) } } func (s *Login_optionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitLogin_option(s) } } @@ -62612,9 +62612,9 @@ func (s *Login_optionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Login_option() (localctx ILogin_optionContext) { +func (p *YQLParser) Login_option() (localctx ILogin_optionContext) { localctx = NewLogin_optionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 584, YQLv1Antlr4ParserRULE_login_option) + p.EnterRule(localctx, 584, YQLParserRULE_login_option) var _la int p.EnterOuterAlt(localctx, 1) @@ -62622,7 +62622,7 @@ func (p *YQLv1Antlr4Parser) Login_option() (localctx ILogin_optionContext) { p.SetState(3549) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserLOGIN || _la == YQLv1Antlr4ParserNOLOGIN) { + if !(_la == YQLParserLOGIN || _la == YQLParserNOLOGIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -62680,13 +62680,13 @@ type Grant_permissions_stmtContext struct { func NewEmptyGrant_permissions_stmtContext() *Grant_permissions_stmtContext { var p = new(Grant_permissions_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grant_permissions_stmt + p.RuleIndex = YQLParserRULE_grant_permissions_stmt return p } func InitEmptyGrant_permissions_stmtContext(p *Grant_permissions_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_grant_permissions_stmt + p.RuleIndex = YQLParserRULE_grant_permissions_stmt } func (*Grant_permissions_stmtContext) IsGrant_permissions_stmtContext() {} @@ -62697,7 +62697,7 @@ func NewGrant_permissions_stmtContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_grant_permissions_stmt + p.RuleIndex = YQLParserRULE_grant_permissions_stmt return p } @@ -62705,11 +62705,11 @@ func NewGrant_permissions_stmtContext(parser antlr.Parser, parent antlr.ParserRu func (s *Grant_permissions_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Grant_permissions_stmtContext) AllGRANT() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserGRANT) + return s.GetTokens(YQLParserGRANT) } func (s *Grant_permissions_stmtContext) GRANT(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGRANT, i) + return s.GetToken(YQLParserGRANT, i) } func (s *Grant_permissions_stmtContext) Permission_name_target() IPermission_name_targetContext { @@ -62729,7 +62729,7 @@ func (s *Grant_permissions_stmtContext) Permission_name_target() IPermission_nam } func (s *Grant_permissions_stmtContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Grant_permissions_stmtContext) AllAn_id_schema() []IAn_id_schemaContext { @@ -62774,7 +62774,7 @@ func (s *Grant_permissions_stmtContext) An_id_schema(i int) IAn_id_schemaContext } func (s *Grant_permissions_stmtContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Grant_permissions_stmtContext) AllRole_name() []IRole_nameContext { @@ -62819,19 +62819,19 @@ func (s *Grant_permissions_stmtContext) Role_name(i int) IRole_nameContext { } func (s *Grant_permissions_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Grant_permissions_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Grant_permissions_stmtContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Grant_permissions_stmtContext) OPTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOPTION, 0) + return s.GetToken(YQLParserOPTION, 0) } func (s *Grant_permissions_stmtContext) GetRuleContext() antlr.RuleContext { @@ -62844,13 +62844,13 @@ func (s *Grant_permissions_stmtContext) ToStringTree(ruleNames []string, recog a func (s *Grant_permissions_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterGrant_permissions_stmt(s) } } func (s *Grant_permissions_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitGrant_permissions_stmt(s) } } @@ -62858,9 +62858,9 @@ func (s *Grant_permissions_stmtContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permissions_stmtContext) { +func (p *YQLParser) Grant_permissions_stmt() (localctx IGrant_permissions_stmtContext) { localctx = NewGrant_permissions_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 586, YQLv1Antlr4ParserRULE_grant_permissions_stmt) + p.EnterRule(localctx, 586, YQLParserRULE_grant_permissions_stmt) var _la int var _alt int @@ -62868,7 +62868,7 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission p.EnterOuterAlt(localctx, 1) { p.SetState(3551) - p.Match(YQLv1Antlr4ParserGRANT) + p.Match(YQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62880,7 +62880,7 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission } { p.SetState(3553) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62898,10 +62898,10 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3555) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62922,7 +62922,7 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission } { p.SetState(3562) - p.Match(YQLv1Antlr4ParserTO) + p.Match(YQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62945,7 +62945,7 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission if _alt == 1 { { p.SetState(3564) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62976,10 +62976,10 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3571) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62995,10 +62995,10 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(3574) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63006,7 +63006,7 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission } { p.SetState(3575) - p.Match(YQLv1Antlr4ParserGRANT) + p.Match(YQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63014,7 +63014,7 @@ func (p *YQLv1Antlr4Parser) Grant_permissions_stmt() (localctx IGrant_permission } { p.SetState(3576) - p.Match(YQLv1Antlr4ParserOPTION) + p.Match(YQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63073,13 +63073,13 @@ type Revoke_permissions_stmtContext struct { func NewEmptyRevoke_permissions_stmtContext() *Revoke_permissions_stmtContext { var p = new(Revoke_permissions_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_revoke_permissions_stmt + p.RuleIndex = YQLParserRULE_revoke_permissions_stmt return p } func InitEmptyRevoke_permissions_stmtContext(p *Revoke_permissions_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_revoke_permissions_stmt + p.RuleIndex = YQLParserRULE_revoke_permissions_stmt } func (*Revoke_permissions_stmtContext) IsRevoke_permissions_stmtContext() {} @@ -63090,7 +63090,7 @@ func NewRevoke_permissions_stmtContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_revoke_permissions_stmt + p.RuleIndex = YQLParserRULE_revoke_permissions_stmt return p } @@ -63098,7 +63098,7 @@ func NewRevoke_permissions_stmtContext(parser antlr.Parser, parent antlr.ParserR func (s *Revoke_permissions_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Revoke_permissions_stmtContext) REVOKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREVOKE, 0) + return s.GetToken(YQLParserREVOKE, 0) } func (s *Revoke_permissions_stmtContext) Permission_name_target() IPermission_name_targetContext { @@ -63118,7 +63118,7 @@ func (s *Revoke_permissions_stmtContext) Permission_name_target() IPermission_na } func (s *Revoke_permissions_stmtContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Revoke_permissions_stmtContext) AllAn_id_schema() []IAn_id_schemaContext { @@ -63163,7 +63163,7 @@ func (s *Revoke_permissions_stmtContext) An_id_schema(i int) IAn_id_schemaContex } func (s *Revoke_permissions_stmtContext) FROM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFROM, 0) + return s.GetToken(YQLParserFROM, 0) } func (s *Revoke_permissions_stmtContext) AllRole_name() []IRole_nameContext { @@ -63208,23 +63208,23 @@ func (s *Revoke_permissions_stmtContext) Role_name(i int) IRole_nameContext { } func (s *Revoke_permissions_stmtContext) GRANT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGRANT, 0) + return s.GetToken(YQLParserGRANT, 0) } func (s *Revoke_permissions_stmtContext) OPTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOPTION, 0) + return s.GetToken(YQLParserOPTION, 0) } func (s *Revoke_permissions_stmtContext) FOR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOR, 0) + return s.GetToken(YQLParserFOR, 0) } func (s *Revoke_permissions_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Revoke_permissions_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Revoke_permissions_stmtContext) GetRuleContext() antlr.RuleContext { @@ -63237,13 +63237,13 @@ func (s *Revoke_permissions_stmtContext) ToStringTree(ruleNames []string, recog func (s *Revoke_permissions_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRevoke_permissions_stmt(s) } } func (s *Revoke_permissions_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRevoke_permissions_stmt(s) } } @@ -63251,15 +63251,15 @@ func (s *Revoke_permissions_stmtContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissions_stmtContext) { +func (p *YQLParser) Revoke_permissions_stmt() (localctx IRevoke_permissions_stmtContext) { localctx = NewRevoke_permissions_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 588, YQLv1Antlr4ParserRULE_revoke_permissions_stmt) + p.EnterRule(localctx, 588, YQLParserRULE_revoke_permissions_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3579) - p.Match(YQLv1Antlr4ParserREVOKE) + p.Match(YQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63272,7 +63272,7 @@ func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissi if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 366, p.GetParserRuleContext()) == 1 { { p.SetState(3580) - p.Match(YQLv1Antlr4ParserGRANT) + p.Match(YQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63280,7 +63280,7 @@ func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissi } { p.SetState(3581) - p.Match(YQLv1Antlr4ParserOPTION) + p.Match(YQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63288,7 +63288,7 @@ func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissi } { p.SetState(3582) - p.Match(YQLv1Antlr4ParserFOR) + p.Match(YQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63304,7 +63304,7 @@ func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissi } { p.SetState(3586) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63322,10 +63322,10 @@ func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissi _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3588) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63346,7 +63346,7 @@ func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissi } { p.SetState(3595) - p.Match(YQLv1Antlr4ParserFROM) + p.Match(YQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63364,10 +63364,10 @@ func (p *YQLv1Antlr4Parser) Revoke_permissions_stmt() (localctx IRevoke_permissi _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3597) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63448,13 +63448,13 @@ type Permission_idContext struct { func NewEmptyPermission_idContext() *Permission_idContext { var p = new(Permission_idContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_id + p.RuleIndex = YQLParserRULE_permission_id return p } func InitEmptyPermission_idContext(p *Permission_idContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_id + p.RuleIndex = YQLParserRULE_permission_id } func (*Permission_idContext) IsPermission_idContext() {} @@ -63465,7 +63465,7 @@ func NewPermission_idContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_id + p.RuleIndex = YQLParserRULE_permission_id return p } @@ -63473,99 +63473,99 @@ func NewPermission_idContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Permission_idContext) GetParser() antlr.Parser { return s.parser } func (s *Permission_idContext) CONNECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONNECT, 0) + return s.GetToken(YQLParserCONNECT, 0) } func (s *Permission_idContext) LIST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIST, 0) + return s.GetToken(YQLParserLIST, 0) } func (s *Permission_idContext) INSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINSERT, 0) + return s.GetToken(YQLParserINSERT, 0) } func (s *Permission_idContext) MANAGE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMANAGE, 0) + return s.GetToken(YQLParserMANAGE, 0) } func (s *Permission_idContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Permission_idContext) GRANT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGRANT, 0) + return s.GetToken(YQLParserGRANT, 0) } func (s *Permission_idContext) MODIFY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMODIFY, 0) + return s.GetToken(YQLParserMODIFY, 0) } func (s *Permission_idContext) TABLES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLES, 0) + return s.GetToken(YQLParserTABLES, 0) } func (s *Permission_idContext) ATTRIBUTES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserATTRIBUTES, 0) + return s.GetToken(YQLParserATTRIBUTES, 0) } func (s *Permission_idContext) ROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROW, 0) + return s.GetToken(YQLParserROW, 0) } func (s *Permission_idContext) UPDATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPDATE, 0) + return s.GetToken(YQLParserUPDATE, 0) } func (s *Permission_idContext) ERASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERASE, 0) + return s.GetToken(YQLParserERASE, 0) } func (s *Permission_idContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSCHEMA, 0) + return s.GetToken(YQLParserSCHEMA, 0) } func (s *Permission_idContext) REMOVE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREMOVE, 0) + return s.GetToken(YQLParserREMOVE, 0) } func (s *Permission_idContext) DESCRIBE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDESCRIBE, 0) + return s.GetToken(YQLParserDESCRIBE, 0) } func (s *Permission_idContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Permission_idContext) SELECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSELECT, 0) + return s.GetToken(YQLParserSELECT, 0) } func (s *Permission_idContext) USE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSE, 0) + return s.GetToken(YQLParserUSE, 0) } func (s *Permission_idContext) FULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFULL, 0) + return s.GetToken(YQLParserFULL, 0) } func (s *Permission_idContext) LEGACY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLEGACY, 0) + return s.GetToken(YQLParserLEGACY, 0) } func (s *Permission_idContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Permission_idContext) DIRECTORY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDIRECTORY, 0) + return s.GetToken(YQLParserDIRECTORY, 0) } func (s *Permission_idContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Permission_idContext) QUEUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUEUE, 0) + return s.GetToken(YQLParserQUEUE, 0) } func (s *Permission_idContext) GetRuleContext() antlr.RuleContext { @@ -63578,13 +63578,13 @@ func (s *Permission_idContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Permission_idContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPermission_id(s) } } func (s *Permission_idContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPermission_id(s) } } @@ -63592,9 +63592,9 @@ func (s *Permission_idContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { +func (p *YQLParser) Permission_id() (localctx IPermission_idContext) { localctx = NewPermission_idContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 590, YQLv1Antlr4ParserRULE_permission_id) + p.EnterRule(localctx, 590, YQLParserRULE_permission_id) var _la int p.SetState(3628) @@ -63604,11 +63604,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserCONNECT: + case YQLParserCONNECT: p.EnterOuterAlt(localctx, 1) { p.SetState(3604) - p.Match(YQLv1Antlr4ParserCONNECT) + p.Match(YQLParserCONNECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63616,11 +63616,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserLIST: + case YQLParserLIST: p.EnterOuterAlt(localctx, 2) { p.SetState(3605) - p.Match(YQLv1Antlr4ParserLIST) + p.Match(YQLParserLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63628,11 +63628,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserINSERT: + case YQLParserINSERT: p.EnterOuterAlt(localctx, 3) { p.SetState(3606) - p.Match(YQLv1Antlr4ParserINSERT) + p.Match(YQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63640,11 +63640,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserMANAGE: + case YQLParserMANAGE: p.EnterOuterAlt(localctx, 4) { p.SetState(3607) - p.Match(YQLv1Antlr4ParserMANAGE) + p.Match(YQLParserMANAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63652,11 +63652,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserDROP: + case YQLParserDROP: p.EnterOuterAlt(localctx, 5) { p.SetState(3608) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63664,11 +63664,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserGRANT: + case YQLParserGRANT: p.EnterOuterAlt(localctx, 6) { p.SetState(3609) - p.Match(YQLv1Antlr4ParserGRANT) + p.Match(YQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63676,11 +63676,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserMODIFY: + case YQLParserMODIFY: p.EnterOuterAlt(localctx, 7) { p.SetState(3610) - p.Match(YQLv1Antlr4ParserMODIFY) + p.Match(YQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63690,7 +63690,7 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { p.SetState(3611) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserATTRIBUTES || _la == YQLv1Antlr4ParserTABLES) { + if !(_la == YQLParserATTRIBUTES || _la == YQLParserTABLES) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -63699,13 +63699,13 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserUPDATE: + case YQLParserERASE, YQLParserUPDATE: p.EnterOuterAlt(localctx, 8) { p.SetState(3612) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserERASE || _la == YQLv1Antlr4ParserUPDATE) { + if !(_la == YQLParserERASE || _la == YQLParserUPDATE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -63714,7 +63714,7 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } { p.SetState(3613) - p.Match(YQLv1Antlr4ParserROW) + p.Match(YQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63722,13 +63722,13 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserREMOVE: + case YQLParserALTER, YQLParserDESCRIBE, YQLParserREMOVE: p.EnterOuterAlt(localctx, 9) { p.SetState(3614) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserALTER || _la == YQLv1Antlr4ParserDESCRIBE || _la == YQLv1Antlr4ParserREMOVE) { + if !(_la == YQLParserALTER || _la == YQLParserDESCRIBE || _la == YQLParserREMOVE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -63737,7 +63737,7 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } { p.SetState(3615) - p.Match(YQLv1Antlr4ParserSCHEMA) + p.Match(YQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63745,11 +63745,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserSELECT: + case YQLParserSELECT: p.EnterOuterAlt(localctx, 10) { p.SetState(3616) - p.Match(YQLv1Antlr4ParserSELECT) + p.Match(YQLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63763,12 +63763,12 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserATTRIBUTES || _la == YQLv1Antlr4ParserROW || _la == YQLv1Antlr4ParserTABLES { + if _la == YQLParserATTRIBUTES || _la == YQLParserROW || _la == YQLParserTABLES { { p.SetState(3617) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserATTRIBUTES || _la == YQLv1Antlr4ParserROW || _la == YQLv1Antlr4ParserTABLES) { + if !(_la == YQLParserATTRIBUTES || _la == YQLParserROW || _la == YQLParserTABLES) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -63779,13 +63779,13 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserUSE: + case YQLParserFULL, YQLParserUSE: p.EnterOuterAlt(localctx, 11) { p.SetState(3620) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserFULL || _la == YQLv1Antlr4ParserUSE) { + if !(_la == YQLParserFULL || _la == YQLParserUSE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -63800,10 +63800,10 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLEGACY { + if _la == YQLParserLEGACY { { p.SetState(3621) - p.Match(YQLv1Antlr4ParserLEGACY) + p.Match(YQLParserLEGACY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63813,11 +63813,11 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { } - case YQLv1Antlr4ParserCREATE: + case YQLParserCREATE: p.EnterOuterAlt(localctx, 12) { p.SetState(3624) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63831,12 +63831,12 @@ func (p *YQLv1Antlr4Parser) Permission_id() (localctx IPermission_idContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDIRECTORY || _la == YQLv1Antlr4ParserQUEUE || _la == YQLv1Antlr4ParserTABLE { + if _la == YQLParserDIRECTORY || _la == YQLParserQUEUE || _la == YQLParserTABLE { { p.SetState(3625) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserDIRECTORY || _la == YQLv1Antlr4ParserQUEUE || _la == YQLv1Antlr4ParserTABLE) { + if !(_la == YQLParserDIRECTORY || _la == YQLParserQUEUE || _la == YQLParserTABLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -63891,13 +63891,13 @@ type Permission_nameContext struct { func NewEmptyPermission_nameContext() *Permission_nameContext { var p = new(Permission_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_name + p.RuleIndex = YQLParserRULE_permission_name return p } func InitEmptyPermission_nameContext(p *Permission_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_name + p.RuleIndex = YQLParserRULE_permission_name } func (*Permission_nameContext) IsPermission_nameContext() {} @@ -63908,7 +63908,7 @@ func NewPermission_nameContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_name + p.RuleIndex = YQLParserRULE_permission_name return p } @@ -63932,7 +63932,7 @@ func (s *Permission_nameContext) Permission_id() IPermission_idContext { } func (s *Permission_nameContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *Permission_nameContext) GetRuleContext() antlr.RuleContext { @@ -63945,13 +63945,13 @@ func (s *Permission_nameContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Permission_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPermission_name(s) } } func (s *Permission_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPermission_name(s) } } @@ -63959,9 +63959,9 @@ func (s *Permission_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Permission_name() (localctx IPermission_nameContext) { +func (p *YQLParser) Permission_name() (localctx IPermission_nameContext) { localctx = NewPermission_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 592, YQLv1Antlr4ParserRULE_permission_name) + p.EnterRule(localctx, 592, YQLParserRULE_permission_name) p.SetState(3632) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -63969,7 +63969,7 @@ func (p *YQLv1Antlr4Parser) Permission_name() (localctx IPermission_nameContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUSE: + case YQLParserALTER, YQLParserCONNECT, YQLParserCREATE, YQLParserDESCRIBE, YQLParserDROP, YQLParserERASE, YQLParserFULL, YQLParserGRANT, YQLParserINSERT, YQLParserLIST, YQLParserMANAGE, YQLParserMODIFY, YQLParserREMOVE, YQLParserSELECT, YQLParserUPDATE, YQLParserUSE: p.EnterOuterAlt(localctx, 1) { p.SetState(3630) @@ -63977,11 +63977,11 @@ func (p *YQLv1Antlr4Parser) Permission_name() (localctx IPermission_nameContext) } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(3631) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64037,13 +64037,13 @@ type Permission_name_targetContext struct { func NewEmptyPermission_name_targetContext() *Permission_name_targetContext { var p = new(Permission_name_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_name_target + p.RuleIndex = YQLParserRULE_permission_name_target return p } func InitEmptyPermission_name_targetContext(p *Permission_name_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_name_target + p.RuleIndex = YQLParserRULE_permission_name_target } func (*Permission_name_targetContext) IsPermission_name_targetContext() {} @@ -64054,7 +64054,7 @@ func NewPermission_name_targetContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_permission_name_target + p.RuleIndex = YQLParserRULE_permission_name_target return p } @@ -64103,19 +64103,19 @@ func (s *Permission_name_targetContext) Permission_name(i int) IPermission_nameC } func (s *Permission_name_targetContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Permission_name_targetContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Permission_name_targetContext) ALL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALL, 0) + return s.GetToken(YQLParserALL, 0) } func (s *Permission_name_targetContext) PRIVILEGES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRIVILEGES, 0) + return s.GetToken(YQLParserPRIVILEGES, 0) } func (s *Permission_name_targetContext) GetRuleContext() antlr.RuleContext { @@ -64128,13 +64128,13 @@ func (s *Permission_name_targetContext) ToStringTree(ruleNames []string, recog a func (s *Permission_name_targetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterPermission_name_target(s) } } func (s *Permission_name_targetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitPermission_name_target(s) } } @@ -64142,9 +64142,9 @@ func (s *Permission_name_targetContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Permission_name_target() (localctx IPermission_name_targetContext) { +func (p *YQLParser) Permission_name_target() (localctx IPermission_name_targetContext) { localctx = NewPermission_name_targetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 594, YQLv1Antlr4ParserRULE_permission_name_target) + p.EnterRule(localctx, 594, YQLParserRULE_permission_name_target) var _la int var _alt int @@ -64156,7 +64156,7 @@ func (p *YQLv1Antlr4Parser) Permission_name_target() (localctx IPermission_name_ } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserALTER, YQLParserCONNECT, YQLParserCREATE, YQLParserDESCRIBE, YQLParserDROP, YQLParserERASE, YQLParserFULL, YQLParserGRANT, YQLParserINSERT, YQLParserLIST, YQLParserMANAGE, YQLParserMODIFY, YQLParserREMOVE, YQLParserSELECT, YQLParserUPDATE, YQLParserUSE, YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 1) { p.SetState(3634) @@ -64175,7 +64175,7 @@ func (p *YQLv1Antlr4Parser) Permission_name_target() (localctx IPermission_name_ if _alt == 1 { { p.SetState(3635) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64206,10 +64206,10 @@ func (p *YQLv1Antlr4Parser) Permission_name_target() (localctx IPermission_name_ _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3642) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64219,11 +64219,11 @@ func (p *YQLv1Antlr4Parser) Permission_name_target() (localctx IPermission_name_ } - case YQLv1Antlr4ParserALL: + case YQLParserALL: p.EnterOuterAlt(localctx, 2) { p.SetState(3645) - p.Match(YQLv1Antlr4ParserALL) + p.Match(YQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64237,10 +64237,10 @@ func (p *YQLv1Antlr4Parser) Permission_name_target() (localctx IPermission_name_ _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPRIVILEGES { + if _la == YQLParserPRIVILEGES { { p.SetState(3646) - p.Match(YQLv1Antlr4ParserPRIVILEGES) + p.Match(YQLParserPRIVILEGES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64297,13 +64297,13 @@ type Create_resource_pool_stmtContext struct { func NewEmptyCreate_resource_pool_stmtContext() *Create_resource_pool_stmtContext { var p = new(Create_resource_pool_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_resource_pool_stmt + p.RuleIndex = YQLParserRULE_create_resource_pool_stmt return p } func InitEmptyCreate_resource_pool_stmtContext(p *Create_resource_pool_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_resource_pool_stmt + p.RuleIndex = YQLParserRULE_create_resource_pool_stmt } func (*Create_resource_pool_stmtContext) IsCreate_resource_pool_stmtContext() {} @@ -64314,7 +64314,7 @@ func NewCreate_resource_pool_stmtContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_resource_pool_stmt + p.RuleIndex = YQLParserRULE_create_resource_pool_stmt return p } @@ -64322,15 +64322,15 @@ func NewCreate_resource_pool_stmtContext(parser antlr.Parser, parent antlr.Parse func (s *Create_resource_pool_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_resource_pool_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_resource_pool_stmtContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Create_resource_pool_stmtContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Create_resource_pool_stmtContext) Object_ref() IObject_refContext { @@ -64375,13 +64375,13 @@ func (s *Create_resource_pool_stmtContext) ToStringTree(ruleNames []string, reco func (s *Create_resource_pool_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_resource_pool_stmt(s) } } func (s *Create_resource_pool_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_resource_pool_stmt(s) } } @@ -64389,13 +64389,13 @@ func (s *Create_resource_pool_stmtContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Create_resource_pool_stmt() (localctx ICreate_resource_pool_stmtContext) { +func (p *YQLParser) Create_resource_pool_stmt() (localctx ICreate_resource_pool_stmtContext) { localctx = NewCreate_resource_pool_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 596, YQLv1Antlr4ParserRULE_create_resource_pool_stmt) + p.EnterRule(localctx, 596, YQLParserRULE_create_resource_pool_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3651) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64403,7 +64403,7 @@ func (p *YQLv1Antlr4Parser) Create_resource_pool_stmt() (localctx ICreate_resour } { p.SetState(3652) - p.Match(YQLv1Antlr4ParserRESOURCE) + p.Match(YQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64411,7 +64411,7 @@ func (p *YQLv1Antlr4Parser) Create_resource_pool_stmt() (localctx ICreate_resour } { p.SetState(3653) - p.Match(YQLv1Antlr4ParserPOOL) + p.Match(YQLParserPOOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64471,13 +64471,13 @@ type Alter_resource_pool_stmtContext struct { func NewEmptyAlter_resource_pool_stmtContext() *Alter_resource_pool_stmtContext { var p = new(Alter_resource_pool_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_stmt + p.RuleIndex = YQLParserRULE_alter_resource_pool_stmt return p } func InitEmptyAlter_resource_pool_stmtContext(p *Alter_resource_pool_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_stmt + p.RuleIndex = YQLParserRULE_alter_resource_pool_stmt } func (*Alter_resource_pool_stmtContext) IsAlter_resource_pool_stmtContext() {} @@ -64488,7 +64488,7 @@ func NewAlter_resource_pool_stmtContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_stmt + p.RuleIndex = YQLParserRULE_alter_resource_pool_stmt return p } @@ -64496,15 +64496,15 @@ func NewAlter_resource_pool_stmtContext(parser antlr.Parser, parent antlr.Parser func (s *Alter_resource_pool_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_resource_pool_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_resource_pool_stmtContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Alter_resource_pool_stmtContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Alter_resource_pool_stmtContext) Object_ref() IObject_refContext { @@ -64565,11 +64565,11 @@ func (s *Alter_resource_pool_stmtContext) Alter_resource_pool_action(i int) IAlt } func (s *Alter_resource_pool_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_resource_pool_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_resource_pool_stmtContext) GetRuleContext() antlr.RuleContext { @@ -64582,13 +64582,13 @@ func (s *Alter_resource_pool_stmtContext) ToStringTree(ruleNames []string, recog func (s *Alter_resource_pool_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_resource_pool_stmt(s) } } func (s *Alter_resource_pool_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_resource_pool_stmt(s) } } @@ -64596,15 +64596,15 @@ func (s *Alter_resource_pool_stmtContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Alter_resource_pool_stmt() (localctx IAlter_resource_pool_stmtContext) { +func (p *YQLParser) Alter_resource_pool_stmt() (localctx IAlter_resource_pool_stmtContext) { localctx = NewAlter_resource_pool_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 598, YQLv1Antlr4ParserRULE_alter_resource_pool_stmt) + p.EnterRule(localctx, 598, YQLParserRULE_alter_resource_pool_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3657) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64612,7 +64612,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_stmt() (localctx IAlter_resource } { p.SetState(3658) - p.Match(YQLv1Antlr4ParserRESOURCE) + p.Match(YQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64620,7 +64620,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_stmt() (localctx IAlter_resource } { p.SetState(3659) - p.Match(YQLv1Antlr4ParserPOOL) + p.Match(YQLParserPOOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64642,10 +64642,10 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_stmt() (localctx IAlter_resource _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3662) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64704,13 +64704,13 @@ type Alter_resource_pool_actionContext struct { func NewEmptyAlter_resource_pool_actionContext() *Alter_resource_pool_actionContext { var p = new(Alter_resource_pool_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_action + p.RuleIndex = YQLParserRULE_alter_resource_pool_action return p } func InitEmptyAlter_resource_pool_actionContext(p *Alter_resource_pool_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_action + p.RuleIndex = YQLParserRULE_alter_resource_pool_action } func (*Alter_resource_pool_actionContext) IsAlter_resource_pool_actionContext() {} @@ -64721,7 +64721,7 @@ func NewAlter_resource_pool_actionContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_action + p.RuleIndex = YQLParserRULE_alter_resource_pool_action return p } @@ -64770,13 +64770,13 @@ func (s *Alter_resource_pool_actionContext) ToStringTree(ruleNames []string, rec func (s *Alter_resource_pool_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_resource_pool_action(s) } } func (s *Alter_resource_pool_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_resource_pool_action(s) } } @@ -64784,9 +64784,9 @@ func (s *Alter_resource_pool_actionContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Alter_resource_pool_action() (localctx IAlter_resource_pool_actionContext) { +func (p *YQLParser) Alter_resource_pool_action() (localctx IAlter_resource_pool_actionContext) { localctx = NewAlter_resource_pool_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 600, YQLv1Antlr4ParserRULE_alter_resource_pool_action) + p.EnterRule(localctx, 600, YQLParserRULE_alter_resource_pool_action) p.SetState(3671) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -64794,7 +64794,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_action() (localctx IAlter_resour } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSET: + case YQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(3669) @@ -64802,7 +64802,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_action() (localctx IAlter_resour } - case YQLv1Antlr4ParserRESET: + case YQLParserRESET: p.EnterOuterAlt(localctx, 2) { p.SetState(3670) @@ -64856,13 +64856,13 @@ type Drop_resource_pool_stmtContext struct { func NewEmptyDrop_resource_pool_stmtContext() *Drop_resource_pool_stmtContext { var p = new(Drop_resource_pool_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_resource_pool_stmt + p.RuleIndex = YQLParserRULE_drop_resource_pool_stmt return p } func InitEmptyDrop_resource_pool_stmtContext(p *Drop_resource_pool_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_resource_pool_stmt + p.RuleIndex = YQLParserRULE_drop_resource_pool_stmt } func (*Drop_resource_pool_stmtContext) IsDrop_resource_pool_stmtContext() {} @@ -64873,7 +64873,7 @@ func NewDrop_resource_pool_stmtContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_resource_pool_stmt + p.RuleIndex = YQLParserRULE_drop_resource_pool_stmt return p } @@ -64881,15 +64881,15 @@ func NewDrop_resource_pool_stmtContext(parser antlr.Parser, parent antlr.ParserR func (s *Drop_resource_pool_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_resource_pool_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_resource_pool_stmtContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Drop_resource_pool_stmtContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Drop_resource_pool_stmtContext) Object_ref() IObject_refContext { @@ -64918,13 +64918,13 @@ func (s *Drop_resource_pool_stmtContext) ToStringTree(ruleNames []string, recog func (s *Drop_resource_pool_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_resource_pool_stmt(s) } } func (s *Drop_resource_pool_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_resource_pool_stmt(s) } } @@ -64932,13 +64932,13 @@ func (s *Drop_resource_pool_stmtContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Drop_resource_pool_stmt() (localctx IDrop_resource_pool_stmtContext) { +func (p *YQLParser) Drop_resource_pool_stmt() (localctx IDrop_resource_pool_stmtContext) { localctx = NewDrop_resource_pool_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 602, YQLv1Antlr4ParserRULE_drop_resource_pool_stmt) + p.EnterRule(localctx, 602, YQLParserRULE_drop_resource_pool_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3673) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64946,7 +64946,7 @@ func (p *YQLv1Antlr4Parser) Drop_resource_pool_stmt() (localctx IDrop_resource_p } { p.SetState(3674) - p.Match(YQLv1Antlr4ParserRESOURCE) + p.Match(YQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64954,7 +64954,7 @@ func (p *YQLv1Antlr4Parser) Drop_resource_pool_stmt() (localctx IDrop_resource_p } { p.SetState(3675) - p.Match(YQLv1Antlr4ParserPOOL) + p.Match(YQLParserPOOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65008,13 +65008,13 @@ type Create_resource_pool_classifier_stmtContext struct { func NewEmptyCreate_resource_pool_classifier_stmtContext() *Create_resource_pool_classifier_stmtContext { var p = new(Create_resource_pool_classifier_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_create_resource_pool_classifier_stmt return p } func InitEmptyCreate_resource_pool_classifier_stmtContext(p *Create_resource_pool_classifier_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_create_resource_pool_classifier_stmt } func (*Create_resource_pool_classifier_stmtContext) IsCreate_resource_pool_classifier_stmtContext() {} @@ -65025,7 +65025,7 @@ func NewCreate_resource_pool_classifier_stmtContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_create_resource_pool_classifier_stmt return p } @@ -65033,19 +65033,19 @@ func NewCreate_resource_pool_classifier_stmtContext(parser antlr.Parser, parent func (s *Create_resource_pool_classifier_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_resource_pool_classifier_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_resource_pool_classifier_stmtContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Create_resource_pool_classifier_stmtContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Create_resource_pool_classifier_stmtContext) CLASSIFIER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCLASSIFIER, 0) + return s.GetToken(YQLParserCLASSIFIER, 0) } func (s *Create_resource_pool_classifier_stmtContext) Object_ref() IObject_refContext { @@ -65090,13 +65090,13 @@ func (s *Create_resource_pool_classifier_stmtContext) ToStringTree(ruleNames []s func (s *Create_resource_pool_classifier_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_resource_pool_classifier_stmt(s) } } func (s *Create_resource_pool_classifier_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_resource_pool_classifier_stmt(s) } } @@ -65104,13 +65104,13 @@ func (s *Create_resource_pool_classifier_stmtContext) ExitRule(listener antlr.Pa -func (p *YQLv1Antlr4Parser) Create_resource_pool_classifier_stmt() (localctx ICreate_resource_pool_classifier_stmtContext) { +func (p *YQLParser) Create_resource_pool_classifier_stmt() (localctx ICreate_resource_pool_classifier_stmtContext) { localctx = NewCreate_resource_pool_classifier_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 604, YQLv1Antlr4ParserRULE_create_resource_pool_classifier_stmt) + p.EnterRule(localctx, 604, YQLParserRULE_create_resource_pool_classifier_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3678) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65118,7 +65118,7 @@ func (p *YQLv1Antlr4Parser) Create_resource_pool_classifier_stmt() (localctx ICr } { p.SetState(3679) - p.Match(YQLv1Antlr4ParserRESOURCE) + p.Match(YQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65126,7 +65126,7 @@ func (p *YQLv1Antlr4Parser) Create_resource_pool_classifier_stmt() (localctx ICr } { p.SetState(3680) - p.Match(YQLv1Antlr4ParserPOOL) + p.Match(YQLParserPOOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65134,7 +65134,7 @@ func (p *YQLv1Antlr4Parser) Create_resource_pool_classifier_stmt() (localctx ICr } { p.SetState(3681) - p.Match(YQLv1Antlr4ParserCLASSIFIER) + p.Match(YQLParserCLASSIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65195,13 +65195,13 @@ type Alter_resource_pool_classifier_stmtContext struct { func NewEmptyAlter_resource_pool_classifier_stmtContext() *Alter_resource_pool_classifier_stmtContext { var p = new(Alter_resource_pool_classifier_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_alter_resource_pool_classifier_stmt return p } func InitEmptyAlter_resource_pool_classifier_stmtContext(p *Alter_resource_pool_classifier_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_alter_resource_pool_classifier_stmt } func (*Alter_resource_pool_classifier_stmtContext) IsAlter_resource_pool_classifier_stmtContext() {} @@ -65212,7 +65212,7 @@ func NewAlter_resource_pool_classifier_stmtContext(parser antlr.Parser, parent a antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_alter_resource_pool_classifier_stmt return p } @@ -65220,19 +65220,19 @@ func NewAlter_resource_pool_classifier_stmtContext(parser antlr.Parser, parent a func (s *Alter_resource_pool_classifier_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_resource_pool_classifier_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_resource_pool_classifier_stmtContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Alter_resource_pool_classifier_stmtContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Alter_resource_pool_classifier_stmtContext) CLASSIFIER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCLASSIFIER, 0) + return s.GetToken(YQLParserCLASSIFIER, 0) } func (s *Alter_resource_pool_classifier_stmtContext) Object_ref() IObject_refContext { @@ -65293,11 +65293,11 @@ func (s *Alter_resource_pool_classifier_stmtContext) Alter_resource_pool_classif } func (s *Alter_resource_pool_classifier_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_resource_pool_classifier_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_resource_pool_classifier_stmtContext) GetRuleContext() antlr.RuleContext { @@ -65310,13 +65310,13 @@ func (s *Alter_resource_pool_classifier_stmtContext) ToStringTree(ruleNames []st func (s *Alter_resource_pool_classifier_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_resource_pool_classifier_stmt(s) } } func (s *Alter_resource_pool_classifier_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_resource_pool_classifier_stmt(s) } } @@ -65324,15 +65324,15 @@ func (s *Alter_resource_pool_classifier_stmtContext) ExitRule(listener antlr.Par -func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_stmt() (localctx IAlter_resource_pool_classifier_stmtContext) { +func (p *YQLParser) Alter_resource_pool_classifier_stmt() (localctx IAlter_resource_pool_classifier_stmtContext) { localctx = NewAlter_resource_pool_classifier_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 606, YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_stmt) + p.EnterRule(localctx, 606, YQLParserRULE_alter_resource_pool_classifier_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3685) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65340,7 +65340,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_stmt() (localctx IAlt } { p.SetState(3686) - p.Match(YQLv1Antlr4ParserRESOURCE) + p.Match(YQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65348,7 +65348,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_stmt() (localctx IAlt } { p.SetState(3687) - p.Match(YQLv1Antlr4ParserPOOL) + p.Match(YQLParserPOOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65356,7 +65356,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_stmt() (localctx IAlt } { p.SetState(3688) - p.Match(YQLv1Antlr4ParserCLASSIFIER) + p.Match(YQLParserCLASSIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65378,10 +65378,10 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_stmt() (localctx IAlt _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3691) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65440,13 +65440,13 @@ type Alter_resource_pool_classifier_actionContext struct { func NewEmptyAlter_resource_pool_classifier_actionContext() *Alter_resource_pool_classifier_actionContext { var p = new(Alter_resource_pool_classifier_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_action + p.RuleIndex = YQLParserRULE_alter_resource_pool_classifier_action return p } func InitEmptyAlter_resource_pool_classifier_actionContext(p *Alter_resource_pool_classifier_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_action + p.RuleIndex = YQLParserRULE_alter_resource_pool_classifier_action } func (*Alter_resource_pool_classifier_actionContext) IsAlter_resource_pool_classifier_actionContext() {} @@ -65457,7 +65457,7 @@ func NewAlter_resource_pool_classifier_actionContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_action + p.RuleIndex = YQLParserRULE_alter_resource_pool_classifier_action return p } @@ -65506,13 +65506,13 @@ func (s *Alter_resource_pool_classifier_actionContext) ToStringTree(ruleNames [] func (s *Alter_resource_pool_classifier_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_resource_pool_classifier_action(s) } } func (s *Alter_resource_pool_classifier_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_resource_pool_classifier_action(s) } } @@ -65520,9 +65520,9 @@ func (s *Alter_resource_pool_classifier_actionContext) ExitRule(listener antlr.P -func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_action() (localctx IAlter_resource_pool_classifier_actionContext) { +func (p *YQLParser) Alter_resource_pool_classifier_action() (localctx IAlter_resource_pool_classifier_actionContext) { localctx = NewAlter_resource_pool_classifier_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 608, YQLv1Antlr4ParserRULE_alter_resource_pool_classifier_action) + p.EnterRule(localctx, 608, YQLParserRULE_alter_resource_pool_classifier_action) p.SetState(3700) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -65530,7 +65530,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_action() (localctx IA } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSET: + case YQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(3698) @@ -65538,7 +65538,7 @@ func (p *YQLv1Antlr4Parser) Alter_resource_pool_classifier_action() (localctx IA } - case YQLv1Antlr4ParserRESET: + case YQLParserRESET: p.EnterOuterAlt(localctx, 2) { p.SetState(3699) @@ -65593,13 +65593,13 @@ type Drop_resource_pool_classifier_stmtContext struct { func NewEmptyDrop_resource_pool_classifier_stmtContext() *Drop_resource_pool_classifier_stmtContext { var p = new(Drop_resource_pool_classifier_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_drop_resource_pool_classifier_stmt return p } func InitEmptyDrop_resource_pool_classifier_stmtContext(p *Drop_resource_pool_classifier_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_drop_resource_pool_classifier_stmt } func (*Drop_resource_pool_classifier_stmtContext) IsDrop_resource_pool_classifier_stmtContext() {} @@ -65610,7 +65610,7 @@ func NewDrop_resource_pool_classifier_stmtContext(parser antlr.Parser, parent an antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_resource_pool_classifier_stmt + p.RuleIndex = YQLParserRULE_drop_resource_pool_classifier_stmt return p } @@ -65618,19 +65618,19 @@ func NewDrop_resource_pool_classifier_stmtContext(parser antlr.Parser, parent an func (s *Drop_resource_pool_classifier_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_resource_pool_classifier_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_resource_pool_classifier_stmtContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Drop_resource_pool_classifier_stmtContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Drop_resource_pool_classifier_stmtContext) CLASSIFIER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCLASSIFIER, 0) + return s.GetToken(YQLParserCLASSIFIER, 0) } func (s *Drop_resource_pool_classifier_stmtContext) Object_ref() IObject_refContext { @@ -65659,13 +65659,13 @@ func (s *Drop_resource_pool_classifier_stmtContext) ToStringTree(ruleNames []str func (s *Drop_resource_pool_classifier_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_resource_pool_classifier_stmt(s) } } func (s *Drop_resource_pool_classifier_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_resource_pool_classifier_stmt(s) } } @@ -65673,13 +65673,13 @@ func (s *Drop_resource_pool_classifier_stmtContext) ExitRule(listener antlr.Pars -func (p *YQLv1Antlr4Parser) Drop_resource_pool_classifier_stmt() (localctx IDrop_resource_pool_classifier_stmtContext) { +func (p *YQLParser) Drop_resource_pool_classifier_stmt() (localctx IDrop_resource_pool_classifier_stmtContext) { localctx = NewDrop_resource_pool_classifier_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 610, YQLv1Antlr4ParserRULE_drop_resource_pool_classifier_stmt) + p.EnterRule(localctx, 610, YQLParserRULE_drop_resource_pool_classifier_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3702) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65687,7 +65687,7 @@ func (p *YQLv1Antlr4Parser) Drop_resource_pool_classifier_stmt() (localctx IDrop } { p.SetState(3703) - p.Match(YQLv1Antlr4ParserRESOURCE) + p.Match(YQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65695,7 +65695,7 @@ func (p *YQLv1Antlr4Parser) Drop_resource_pool_classifier_stmt() (localctx IDrop } { p.SetState(3704) - p.Match(YQLv1Antlr4ParserPOOL) + p.Match(YQLParserPOOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65703,7 +65703,7 @@ func (p *YQLv1Antlr4Parser) Drop_resource_pool_classifier_stmt() (localctx IDrop } { p.SetState(3705) - p.Match(YQLv1Antlr4ParserCLASSIFIER) + p.Match(YQLParserCLASSIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65764,13 +65764,13 @@ type Create_replication_stmtContext struct { func NewEmptyCreate_replication_stmtContext() *Create_replication_stmtContext { var p = new(Create_replication_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_replication_stmt + p.RuleIndex = YQLParserRULE_create_replication_stmt return p } func InitEmptyCreate_replication_stmtContext(p *Create_replication_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_replication_stmt + p.RuleIndex = YQLParserRULE_create_replication_stmt } func (*Create_replication_stmtContext) IsCreate_replication_stmtContext() {} @@ -65781,7 +65781,7 @@ func NewCreate_replication_stmtContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_replication_stmt + p.RuleIndex = YQLParserRULE_create_replication_stmt return p } @@ -65789,15 +65789,15 @@ func NewCreate_replication_stmtContext(parser antlr.Parser, parent antlr.ParserR func (s *Create_replication_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_replication_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_replication_stmtContext) ASYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYNC, 0) + return s.GetToken(YQLParserASYNC, 0) } func (s *Create_replication_stmtContext) REPLICATION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLICATION, 0) + return s.GetToken(YQLParserREPLICATION, 0) } func (s *Create_replication_stmtContext) Object_ref() IObject_refContext { @@ -65817,7 +65817,7 @@ func (s *Create_replication_stmtContext) Object_ref() IObject_refContext { } func (s *Create_replication_stmtContext) FOR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOR, 0) + return s.GetToken(YQLParserFOR, 0) } func (s *Create_replication_stmtContext) AllReplication_target() []IReplication_targetContext { @@ -65862,11 +65862,11 @@ func (s *Create_replication_stmtContext) Replication_target(i int) IReplication_ } func (s *Create_replication_stmtContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Create_replication_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Create_replication_stmtContext) Replication_settings() IReplication_settingsContext { @@ -65886,15 +65886,15 @@ func (s *Create_replication_stmtContext) Replication_settings() IReplication_set } func (s *Create_replication_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Create_replication_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Create_replication_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Create_replication_stmtContext) GetRuleContext() antlr.RuleContext { @@ -65907,13 +65907,13 @@ func (s *Create_replication_stmtContext) ToStringTree(ruleNames []string, recog func (s *Create_replication_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_replication_stmt(s) } } func (s *Create_replication_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_replication_stmt(s) } } @@ -65921,15 +65921,15 @@ func (s *Create_replication_stmtContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replication_stmtContext) { +func (p *YQLParser) Create_replication_stmt() (localctx ICreate_replication_stmtContext) { localctx = NewCreate_replication_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 612, YQLv1Antlr4ParserRULE_create_replication_stmt) + p.EnterRule(localctx, 612, YQLParserRULE_create_replication_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3708) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65937,7 +65937,7 @@ func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replicat } { p.SetState(3709) - p.Match(YQLv1Antlr4ParserASYNC) + p.Match(YQLParserASYNC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65945,7 +65945,7 @@ func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replicat } { p.SetState(3710) - p.Match(YQLv1Antlr4ParserREPLICATION) + p.Match(YQLParserREPLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65957,7 +65957,7 @@ func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replicat } { p.SetState(3712) - p.Match(YQLv1Antlr4ParserFOR) + p.Match(YQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65975,10 +65975,10 @@ func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replicat _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3714) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65999,7 +65999,7 @@ func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replicat } { p.SetState(3721) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66007,7 +66007,7 @@ func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replicat } { p.SetState(3722) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66019,7 +66019,7 @@ func (p *YQLv1Antlr4Parser) Create_replication_stmt() (localctx ICreate_replicat } { p.SetState(3724) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66066,13 +66066,13 @@ type Replication_targetContext struct { func NewEmptyReplication_targetContext() *Replication_targetContext { var p = new(Replication_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_target + p.RuleIndex = YQLParserRULE_replication_target return p } func InitEmptyReplication_targetContext(p *Replication_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_target + p.RuleIndex = YQLParserRULE_replication_target } func (*Replication_targetContext) IsReplication_targetContext() {} @@ -66083,7 +66083,7 @@ func NewReplication_targetContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_target + p.RuleIndex = YQLParserRULE_replication_target return p } @@ -66132,7 +66132,7 @@ func (s *Replication_targetContext) Object_ref(i int) IObject_refContext { } func (s *Replication_targetContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Replication_targetContext) GetRuleContext() antlr.RuleContext { @@ -66145,13 +66145,13 @@ func (s *Replication_targetContext) ToStringTree(ruleNames []string, recog antlr func (s *Replication_targetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterReplication_target(s) } } func (s *Replication_targetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitReplication_target(s) } } @@ -66159,9 +66159,9 @@ func (s *Replication_targetContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Replication_target() (localctx IReplication_targetContext) { +func (p *YQLParser) Replication_target() (localctx IReplication_targetContext) { localctx = NewReplication_targetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 614, YQLv1Antlr4ParserRULE_replication_target) + p.EnterRule(localctx, 614, YQLParserRULE_replication_target) p.EnterOuterAlt(localctx, 1) { p.SetState(3726) @@ -66169,7 +66169,7 @@ func (p *YQLv1Antlr4Parser) Replication_target() (localctx IReplication_targetCo } { p.SetState(3727) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66221,13 +66221,13 @@ type Replication_settingsContext struct { func NewEmptyReplication_settingsContext() *Replication_settingsContext { var p = new(Replication_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_settings + p.RuleIndex = YQLParserRULE_replication_settings return p } func InitEmptyReplication_settingsContext(p *Replication_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_settings + p.RuleIndex = YQLParserRULE_replication_settings } func (*Replication_settingsContext) IsReplication_settingsContext() {} @@ -66238,7 +66238,7 @@ func NewReplication_settingsContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_settings + p.RuleIndex = YQLParserRULE_replication_settings return p } @@ -66287,11 +66287,11 @@ func (s *Replication_settingsContext) Replication_settings_entry(i int) IReplica } func (s *Replication_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Replication_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Replication_settingsContext) GetRuleContext() antlr.RuleContext { @@ -66304,13 +66304,13 @@ func (s *Replication_settingsContext) ToStringTree(ruleNames []string, recog ant func (s *Replication_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterReplication_settings(s) } } func (s *Replication_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitReplication_settings(s) } } @@ -66318,9 +66318,9 @@ func (s *Replication_settingsContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Replication_settings() (localctx IReplication_settingsContext) { +func (p *YQLParser) Replication_settings() (localctx IReplication_settingsContext) { localctx = NewReplication_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 616, YQLv1Antlr4ParserRULE_replication_settings) + p.EnterRule(localctx, 616, YQLParserRULE_replication_settings) var _la int p.EnterOuterAlt(localctx, 1) @@ -66336,10 +66336,10 @@ func (p *YQLv1Antlr4Parser) Replication_settings() (localctx IReplication_settin _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3731) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66399,13 +66399,13 @@ type Replication_settings_entryContext struct { func NewEmptyReplication_settings_entryContext() *Replication_settings_entryContext { var p = new(Replication_settings_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_settings_entry + p.RuleIndex = YQLParserRULE_replication_settings_entry return p } func InitEmptyReplication_settings_entryContext(p *Replication_settings_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_settings_entry + p.RuleIndex = YQLParserRULE_replication_settings_entry } func (*Replication_settings_entryContext) IsReplication_settings_entryContext() {} @@ -66416,7 +66416,7 @@ func NewReplication_settings_entryContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_replication_settings_entry + p.RuleIndex = YQLParserRULE_replication_settings_entry return p } @@ -66440,7 +66440,7 @@ func (s *Replication_settings_entryContext) An_id() IAn_idContext { } func (s *Replication_settings_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Replication_settings_entryContext) Expr() IExprContext { @@ -66469,13 +66469,13 @@ func (s *Replication_settings_entryContext) ToStringTree(ruleNames []string, rec func (s *Replication_settings_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterReplication_settings_entry(s) } } func (s *Replication_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitReplication_settings_entry(s) } } @@ -66483,9 +66483,9 @@ func (s *Replication_settings_entryContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Replication_settings_entry() (localctx IReplication_settings_entryContext) { +func (p *YQLParser) Replication_settings_entry() (localctx IReplication_settings_entryContext) { localctx = NewReplication_settings_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 618, YQLv1Antlr4ParserRULE_replication_settings_entry) + p.EnterRule(localctx, 618, YQLParserRULE_replication_settings_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(3738) @@ -66493,7 +66493,7 @@ func (p *YQLv1Antlr4Parser) Replication_settings_entry() (localctx IReplication_ } { p.SetState(3739) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66549,13 +66549,13 @@ type Alter_replication_stmtContext struct { func NewEmptyAlter_replication_stmtContext() *Alter_replication_stmtContext { var p = new(Alter_replication_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_stmt + p.RuleIndex = YQLParserRULE_alter_replication_stmt return p } func InitEmptyAlter_replication_stmtContext(p *Alter_replication_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_stmt + p.RuleIndex = YQLParserRULE_alter_replication_stmt } func (*Alter_replication_stmtContext) IsAlter_replication_stmtContext() {} @@ -66566,7 +66566,7 @@ func NewAlter_replication_stmtContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_stmt + p.RuleIndex = YQLParserRULE_alter_replication_stmt return p } @@ -66574,15 +66574,15 @@ func NewAlter_replication_stmtContext(parser antlr.Parser, parent antlr.ParserRu func (s *Alter_replication_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_replication_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_replication_stmtContext) ASYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYNC, 0) + return s.GetToken(YQLParserASYNC, 0) } func (s *Alter_replication_stmtContext) REPLICATION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLICATION, 0) + return s.GetToken(YQLParserREPLICATION, 0) } func (s *Alter_replication_stmtContext) Object_ref() IObject_refContext { @@ -66643,11 +66643,11 @@ func (s *Alter_replication_stmtContext) Alter_replication_action(i int) IAlter_r } func (s *Alter_replication_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_replication_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_replication_stmtContext) GetRuleContext() antlr.RuleContext { @@ -66660,13 +66660,13 @@ func (s *Alter_replication_stmtContext) ToStringTree(ruleNames []string, recog a func (s *Alter_replication_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_replication_stmt(s) } } func (s *Alter_replication_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_replication_stmt(s) } } @@ -66674,15 +66674,15 @@ func (s *Alter_replication_stmtContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Alter_replication_stmt() (localctx IAlter_replication_stmtContext) { +func (p *YQLParser) Alter_replication_stmt() (localctx IAlter_replication_stmtContext) { localctx = NewAlter_replication_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 620, YQLv1Antlr4ParserRULE_alter_replication_stmt) + p.EnterRule(localctx, 620, YQLParserRULE_alter_replication_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3742) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66690,7 +66690,7 @@ func (p *YQLv1Antlr4Parser) Alter_replication_stmt() (localctx IAlter_replicatio } { p.SetState(3743) - p.Match(YQLv1Antlr4ParserASYNC) + p.Match(YQLParserASYNC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66698,7 +66698,7 @@ func (p *YQLv1Antlr4Parser) Alter_replication_stmt() (localctx IAlter_replicatio } { p.SetState(3744) - p.Match(YQLv1Antlr4ParserREPLICATION) + p.Match(YQLParserREPLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66720,10 +66720,10 @@ func (p *YQLv1Antlr4Parser) Alter_replication_stmt() (localctx IAlter_replicatio _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3747) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66781,13 +66781,13 @@ type Alter_replication_actionContext struct { func NewEmptyAlter_replication_actionContext() *Alter_replication_actionContext { var p = new(Alter_replication_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_action + p.RuleIndex = YQLParserRULE_alter_replication_action return p } func InitEmptyAlter_replication_actionContext(p *Alter_replication_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_action + p.RuleIndex = YQLParserRULE_alter_replication_action } func (*Alter_replication_actionContext) IsAlter_replication_actionContext() {} @@ -66798,7 +66798,7 @@ func NewAlter_replication_actionContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_action + p.RuleIndex = YQLParserRULE_alter_replication_action return p } @@ -66831,13 +66831,13 @@ func (s *Alter_replication_actionContext) ToStringTree(ruleNames []string, recog func (s *Alter_replication_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_replication_action(s) } } func (s *Alter_replication_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_replication_action(s) } } @@ -66845,9 +66845,9 @@ func (s *Alter_replication_actionContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Alter_replication_action() (localctx IAlter_replication_actionContext) { +func (p *YQLParser) Alter_replication_action() (localctx IAlter_replication_actionContext) { localctx = NewAlter_replication_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 622, YQLv1Antlr4ParserRULE_alter_replication_action) + p.EnterRule(localctx, 622, YQLParserRULE_alter_replication_action) p.EnterOuterAlt(localctx, 1) { p.SetState(3754) @@ -66895,13 +66895,13 @@ type Alter_replication_set_settingContext struct { func NewEmptyAlter_replication_set_settingContext() *Alter_replication_set_settingContext { var p = new(Alter_replication_set_settingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_set_setting + p.RuleIndex = YQLParserRULE_alter_replication_set_setting return p } func InitEmptyAlter_replication_set_settingContext(p *Alter_replication_set_settingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_set_setting + p.RuleIndex = YQLParserRULE_alter_replication_set_setting } func (*Alter_replication_set_settingContext) IsAlter_replication_set_settingContext() {} @@ -66912,7 +66912,7 @@ func NewAlter_replication_set_settingContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_replication_set_setting + p.RuleIndex = YQLParserRULE_alter_replication_set_setting return p } @@ -66920,11 +66920,11 @@ func NewAlter_replication_set_settingContext(parser antlr.Parser, parent antlr.P func (s *Alter_replication_set_settingContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_replication_set_settingContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Alter_replication_set_settingContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Alter_replication_set_settingContext) Replication_settings() IReplication_settingsContext { @@ -66944,7 +66944,7 @@ func (s *Alter_replication_set_settingContext) Replication_settings() IReplicati } func (s *Alter_replication_set_settingContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Alter_replication_set_settingContext) GetRuleContext() antlr.RuleContext { @@ -66957,13 +66957,13 @@ func (s *Alter_replication_set_settingContext) ToStringTree(ruleNames []string, func (s *Alter_replication_set_settingContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_replication_set_setting(s) } } func (s *Alter_replication_set_settingContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_replication_set_setting(s) } } @@ -66971,13 +66971,13 @@ func (s *Alter_replication_set_settingContext) ExitRule(listener antlr.ParseTree -func (p *YQLv1Antlr4Parser) Alter_replication_set_setting() (localctx IAlter_replication_set_settingContext) { +func (p *YQLParser) Alter_replication_set_setting() (localctx IAlter_replication_set_settingContext) { localctx = NewAlter_replication_set_settingContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 624, YQLv1Antlr4ParserRULE_alter_replication_set_setting) + p.EnterRule(localctx, 624, YQLParserRULE_alter_replication_set_setting) p.EnterOuterAlt(localctx, 1) { p.SetState(3756) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66985,7 +66985,7 @@ func (p *YQLv1Antlr4Parser) Alter_replication_set_setting() (localctx IAlter_rep } { p.SetState(3757) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66997,7 +66997,7 @@ func (p *YQLv1Antlr4Parser) Alter_replication_set_setting() (localctx IAlter_rep } { p.SetState(3759) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67046,13 +67046,13 @@ type Drop_replication_stmtContext struct { func NewEmptyDrop_replication_stmtContext() *Drop_replication_stmtContext { var p = new(Drop_replication_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_replication_stmt + p.RuleIndex = YQLParserRULE_drop_replication_stmt return p } func InitEmptyDrop_replication_stmtContext(p *Drop_replication_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_replication_stmt + p.RuleIndex = YQLParserRULE_drop_replication_stmt } func (*Drop_replication_stmtContext) IsDrop_replication_stmtContext() {} @@ -67063,7 +67063,7 @@ func NewDrop_replication_stmtContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_replication_stmt + p.RuleIndex = YQLParserRULE_drop_replication_stmt return p } @@ -67071,15 +67071,15 @@ func NewDrop_replication_stmtContext(parser antlr.Parser, parent antlr.ParserRul func (s *Drop_replication_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_replication_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_replication_stmtContext) ASYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYNC, 0) + return s.GetToken(YQLParserASYNC, 0) } func (s *Drop_replication_stmtContext) REPLICATION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLICATION, 0) + return s.GetToken(YQLParserREPLICATION, 0) } func (s *Drop_replication_stmtContext) Object_ref() IObject_refContext { @@ -67099,7 +67099,7 @@ func (s *Drop_replication_stmtContext) Object_ref() IObject_refContext { } func (s *Drop_replication_stmtContext) CASCADE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCASCADE, 0) + return s.GetToken(YQLParserCASCADE, 0) } func (s *Drop_replication_stmtContext) GetRuleContext() antlr.RuleContext { @@ -67112,13 +67112,13 @@ func (s *Drop_replication_stmtContext) ToStringTree(ruleNames []string, recog an func (s *Drop_replication_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_replication_stmt(s) } } func (s *Drop_replication_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_replication_stmt(s) } } @@ -67126,15 +67126,15 @@ func (s *Drop_replication_stmtContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Drop_replication_stmt() (localctx IDrop_replication_stmtContext) { +func (p *YQLParser) Drop_replication_stmt() (localctx IDrop_replication_stmtContext) { localctx = NewDrop_replication_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 626, YQLv1Antlr4ParserRULE_drop_replication_stmt) + p.EnterRule(localctx, 626, YQLParserRULE_drop_replication_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3761) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67142,7 +67142,7 @@ func (p *YQLv1Antlr4Parser) Drop_replication_stmt() (localctx IDrop_replication_ } { p.SetState(3762) - p.Match(YQLv1Antlr4ParserASYNC) + p.Match(YQLParserASYNC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67150,7 +67150,7 @@ func (p *YQLv1Antlr4Parser) Drop_replication_stmt() (localctx IDrop_replication_ } { p.SetState(3763) - p.Match(YQLv1Antlr4ParserREPLICATION) + p.Match(YQLParserREPLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67168,10 +67168,10 @@ func (p *YQLv1Antlr4Parser) Drop_replication_stmt() (localctx IDrop_replication_ _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCASCADE { + if _la == YQLParserCASCADE { { p.SetState(3765) - p.Match(YQLv1Antlr4ParserCASCADE) + p.Match(YQLParserCASCADE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67221,13 +67221,13 @@ type Action_or_subquery_argsContext struct { func NewEmptyAction_or_subquery_argsContext() *Action_or_subquery_argsContext { var p = new(Action_or_subquery_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_action_or_subquery_args + p.RuleIndex = YQLParserRULE_action_or_subquery_args return p } func InitEmptyAction_or_subquery_argsContext(p *Action_or_subquery_argsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_action_or_subquery_args + p.RuleIndex = YQLParserRULE_action_or_subquery_args } func (*Action_or_subquery_argsContext) IsAction_or_subquery_argsContext() {} @@ -67238,7 +67238,7 @@ func NewAction_or_subquery_argsContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_action_or_subquery_args + p.RuleIndex = YQLParserRULE_action_or_subquery_args return p } @@ -67287,11 +67287,11 @@ func (s *Action_or_subquery_argsContext) Opt_bind_parameter(i int) IOpt_bind_par } func (s *Action_or_subquery_argsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Action_or_subquery_argsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Action_or_subquery_argsContext) GetRuleContext() antlr.RuleContext { @@ -67304,13 +67304,13 @@ func (s *Action_or_subquery_argsContext) ToStringTree(ruleNames []string, recog func (s *Action_or_subquery_argsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAction_or_subquery_args(s) } } func (s *Action_or_subquery_argsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAction_or_subquery_args(s) } } @@ -67318,9 +67318,9 @@ func (s *Action_or_subquery_argsContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Action_or_subquery_args() (localctx IAction_or_subquery_argsContext) { +func (p *YQLParser) Action_or_subquery_args() (localctx IAction_or_subquery_argsContext) { localctx = NewAction_or_subquery_argsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 628, YQLv1Antlr4ParserRULE_action_or_subquery_args) + p.EnterRule(localctx, 628, YQLParserRULE_action_or_subquery_args) var _la int p.EnterOuterAlt(localctx, 1) @@ -67336,10 +67336,10 @@ func (p *YQLv1Antlr4Parser) Action_or_subquery_args() (localctx IAction_or_subqu _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3769) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67407,13 +67407,13 @@ type Define_action_or_subquery_stmtContext struct { func NewEmptyDefine_action_or_subquery_stmtContext() *Define_action_or_subquery_stmtContext { var p = new(Define_action_or_subquery_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_define_action_or_subquery_stmt + p.RuleIndex = YQLParserRULE_define_action_or_subquery_stmt return p } func InitEmptyDefine_action_or_subquery_stmtContext(p *Define_action_or_subquery_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_define_action_or_subquery_stmt + p.RuleIndex = YQLParserRULE_define_action_or_subquery_stmt } func (*Define_action_or_subquery_stmtContext) IsDefine_action_or_subquery_stmtContext() {} @@ -67424,7 +67424,7 @@ func NewDefine_action_or_subquery_stmtContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_define_action_or_subquery_stmt + p.RuleIndex = YQLParserRULE_define_action_or_subquery_stmt return p } @@ -67432,11 +67432,11 @@ func NewDefine_action_or_subquery_stmtContext(parser antlr.Parser, parent antlr. func (s *Define_action_or_subquery_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Define_action_or_subquery_stmtContext) AllDEFINE() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserDEFINE) + return s.GetTokens(YQLParserDEFINE) } func (s *Define_action_or_subquery_stmtContext) DEFINE(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFINE, i) + return s.GetToken(YQLParserDEFINE, i) } func (s *Define_action_or_subquery_stmtContext) Bind_parameter() IBind_parameterContext { @@ -67456,15 +67456,15 @@ func (s *Define_action_or_subquery_stmtContext) Bind_parameter() IBind_parameter } func (s *Define_action_or_subquery_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Define_action_or_subquery_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Define_action_or_subquery_stmtContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Define_action_or_subquery_stmtContext) Define_action_or_subquery_body() IDefine_action_or_subquery_bodyContext { @@ -67484,15 +67484,15 @@ func (s *Define_action_or_subquery_stmtContext) Define_action_or_subquery_body() } func (s *Define_action_or_subquery_stmtContext) END() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEND, 0) + return s.GetToken(YQLParserEND, 0) } func (s *Define_action_or_subquery_stmtContext) ACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserACTION, 0) + return s.GetToken(YQLParserACTION, 0) } func (s *Define_action_or_subquery_stmtContext) SUBQUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSUBQUERY, 0) + return s.GetToken(YQLParserSUBQUERY, 0) } func (s *Define_action_or_subquery_stmtContext) Action_or_subquery_args() IAction_or_subquery_argsContext { @@ -67521,13 +67521,13 @@ func (s *Define_action_or_subquery_stmtContext) ToStringTree(ruleNames []string, func (s *Define_action_or_subquery_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDefine_action_or_subquery_stmt(s) } } func (s *Define_action_or_subquery_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDefine_action_or_subquery_stmt(s) } } @@ -67535,15 +67535,15 @@ func (s *Define_action_or_subquery_stmtContext) ExitRule(listener antlr.ParseTre -func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_action_or_subquery_stmtContext) { +func (p *YQLParser) Define_action_or_subquery_stmt() (localctx IDefine_action_or_subquery_stmtContext) { localctx = NewDefine_action_or_subquery_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 630, YQLv1Antlr4ParserRULE_define_action_or_subquery_stmt) + p.EnterRule(localctx, 630, YQLParserRULE_define_action_or_subquery_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3776) - p.Match(YQLv1Antlr4ParserDEFINE) + p.Match(YQLParserDEFINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67553,7 +67553,7 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_a p.SetState(3777) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserACTION || _la == YQLv1Antlr4ParserSUBQUERY) { + if !(_la == YQLParserACTION || _la == YQLParserSUBQUERY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -67566,7 +67566,7 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_a } { p.SetState(3779) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67580,7 +67580,7 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_a _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserDOLLAR { + if _la == YQLParserDOLLAR { { p.SetState(3780) p.Action_or_subquery_args() @@ -67589,7 +67589,7 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_a } { p.SetState(3783) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67597,7 +67597,7 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_a } { p.SetState(3784) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67609,7 +67609,7 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_a } { p.SetState(3786) - p.Match(YQLv1Antlr4ParserEND) + p.Match(YQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67617,7 +67617,7 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_stmt() (localctx IDefine_a } { p.SetState(3787) - p.Match(YQLv1Antlr4ParserDEFINE) + p.Match(YQLParserDEFINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67665,13 +67665,13 @@ type Define_action_or_subquery_bodyContext struct { func NewEmptyDefine_action_or_subquery_bodyContext() *Define_action_or_subquery_bodyContext { var p = new(Define_action_or_subquery_bodyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_define_action_or_subquery_body + p.RuleIndex = YQLParserRULE_define_action_or_subquery_body return p } func InitEmptyDefine_action_or_subquery_bodyContext(p *Define_action_or_subquery_bodyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_define_action_or_subquery_body + p.RuleIndex = YQLParserRULE_define_action_or_subquery_body } func (*Define_action_or_subquery_bodyContext) IsDefine_action_or_subquery_bodyContext() {} @@ -67682,7 +67682,7 @@ func NewDefine_action_or_subquery_bodyContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_define_action_or_subquery_body + p.RuleIndex = YQLParserRULE_define_action_or_subquery_body return p } @@ -67690,11 +67690,11 @@ func NewDefine_action_or_subquery_bodyContext(parser antlr.Parser, parent antlr. func (s *Define_action_or_subquery_bodyContext) GetParser() antlr.Parser { return s.parser } func (s *Define_action_or_subquery_bodyContext) AllSEMICOLON() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserSEMICOLON) + return s.GetTokens(YQLParserSEMICOLON) } func (s *Define_action_or_subquery_bodyContext) SEMICOLON(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEMICOLON, i) + return s.GetToken(YQLParserSEMICOLON, i) } func (s *Define_action_or_subquery_bodyContext) AllSql_stmt_core() []ISql_stmt_coreContext { @@ -67748,13 +67748,13 @@ func (s *Define_action_or_subquery_bodyContext) ToStringTree(ruleNames []string, func (s *Define_action_or_subquery_bodyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDefine_action_or_subquery_body(s) } } func (s *Define_action_or_subquery_bodyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDefine_action_or_subquery_body(s) } } @@ -67762,9 +67762,9 @@ func (s *Define_action_or_subquery_bodyContext) ExitRule(listener antlr.ParseTre -func (p *YQLv1Antlr4Parser) Define_action_or_subquery_body() (localctx IDefine_action_or_subquery_bodyContext) { +func (p *YQLParser) Define_action_or_subquery_body() (localctx IDefine_action_or_subquery_bodyContext) { localctx = NewDefine_action_or_subquery_bodyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 632, YQLv1Antlr4ParserRULE_define_action_or_subquery_body) + p.EnterRule(localctx, 632, YQLParserRULE_define_action_or_subquery_body) var _la int var _alt int @@ -67778,10 +67778,10 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_body() (localctx IDefine_a _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserSEMICOLON { + for _la == YQLParserSEMICOLON { { p.SetState(3789) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67828,10 +67828,10 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_body() (localctx IDefine_a _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == YQLv1Antlr4ParserSEMICOLON { + for ok := true; ok; ok = _la == YQLParserSEMICOLON { { p.SetState(3796) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67871,10 +67871,10 @@ func (p *YQLv1Antlr4Parser) Define_action_or_subquery_body() (localctx IDefine_a _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserSEMICOLON { + for _la == YQLParserSEMICOLON { { p.SetState(3807) - p.Match(YQLv1Antlr4ParserSEMICOLON) + p.Match(YQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67935,13 +67935,13 @@ type If_stmtContext struct { func NewEmptyIf_stmtContext() *If_stmtContext { var p = new(If_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_if_stmt + p.RuleIndex = YQLParserRULE_if_stmt return p } func InitEmptyIf_stmtContext(p *If_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_if_stmt + p.RuleIndex = YQLParserRULE_if_stmt } func (*If_stmtContext) IsIf_stmtContext() {} @@ -67952,7 +67952,7 @@ func NewIf_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_if_stmt + p.RuleIndex = YQLParserRULE_if_stmt return p } @@ -67960,7 +67960,7 @@ func NewIf_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *If_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *If_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *If_stmtContext) Expr() IExprContext { @@ -68021,11 +68021,11 @@ func (s *If_stmtContext) Do_stmt(i int) IDo_stmtContext { } func (s *If_stmtContext) EVALUATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEVALUATE, 0) + return s.GetToken(YQLParserEVALUATE, 0) } func (s *If_stmtContext) ELSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserELSE, 0) + return s.GetToken(YQLParserELSE, 0) } func (s *If_stmtContext) GetRuleContext() antlr.RuleContext { @@ -68038,13 +68038,13 @@ func (s *If_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *If_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIf_stmt(s) } } func (s *If_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIf_stmt(s) } } @@ -68052,9 +68052,9 @@ func (s *If_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) If_stmt() (localctx IIf_stmtContext) { +func (p *YQLParser) If_stmt() (localctx IIf_stmtContext) { localctx = NewIf_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 634, YQLv1Antlr4ParserRULE_if_stmt) + p.EnterRule(localctx, 634, YQLParserRULE_if_stmt) var _la int p.EnterOuterAlt(localctx, 1) @@ -68066,10 +68066,10 @@ func (p *YQLv1Antlr4Parser) If_stmt() (localctx IIf_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEVALUATE { + if _la == YQLParserEVALUATE { { p.SetState(3815) - p.Match(YQLv1Antlr4ParserEVALUATE) + p.Match(YQLParserEVALUATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68079,7 +68079,7 @@ func (p *YQLv1Antlr4Parser) If_stmt() (localctx IIf_stmtContext) { } { p.SetState(3818) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68101,10 +68101,10 @@ func (p *YQLv1Antlr4Parser) If_stmt() (localctx IIf_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserELSE { + if _la == YQLParserELSE { { p.SetState(3821) - p.Match(YQLv1Antlr4ParserELSE) + p.Match(YQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68163,13 +68163,13 @@ type For_stmtContext struct { func NewEmptyFor_stmtContext() *For_stmtContext { var p = new(For_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_for_stmt + p.RuleIndex = YQLParserRULE_for_stmt return p } func InitEmptyFor_stmtContext(p *For_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_for_stmt + p.RuleIndex = YQLParserRULE_for_stmt } func (*For_stmtContext) IsFor_stmtContext() {} @@ -68180,7 +68180,7 @@ func NewFor_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_for_stmt + p.RuleIndex = YQLParserRULE_for_stmt return p } @@ -68188,7 +68188,7 @@ func NewFor_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *For_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *For_stmtContext) FOR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOR, 0) + return s.GetToken(YQLParserFOR, 0) } func (s *For_stmtContext) Bind_parameter() IBind_parameterContext { @@ -68208,7 +68208,7 @@ func (s *For_stmtContext) Bind_parameter() IBind_parameterContext { } func (s *For_stmtContext) IN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIN, 0) + return s.GetToken(YQLParserIN, 0) } func (s *For_stmtContext) Expr() IExprContext { @@ -68269,15 +68269,15 @@ func (s *For_stmtContext) Do_stmt(i int) IDo_stmtContext { } func (s *For_stmtContext) EVALUATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEVALUATE, 0) + return s.GetToken(YQLParserEVALUATE, 0) } func (s *For_stmtContext) PARALLEL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARALLEL, 0) + return s.GetToken(YQLParserPARALLEL, 0) } func (s *For_stmtContext) ELSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserELSE, 0) + return s.GetToken(YQLParserELSE, 0) } func (s *For_stmtContext) GetRuleContext() antlr.RuleContext { @@ -68290,13 +68290,13 @@ func (s *For_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *For_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFor_stmt(s) } } func (s *For_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFor_stmt(s) } } @@ -68304,9 +68304,9 @@ func (s *For_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) For_stmt() (localctx IFor_stmtContext) { +func (p *YQLParser) For_stmt() (localctx IFor_stmtContext) { localctx = NewFor_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 636, YQLv1Antlr4ParserRULE_for_stmt) + p.EnterRule(localctx, 636, YQLParserRULE_for_stmt) var _la int p.EnterOuterAlt(localctx, 1) @@ -68318,10 +68318,10 @@ func (p *YQLv1Antlr4Parser) For_stmt() (localctx IFor_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEVALUATE { + if _la == YQLParserEVALUATE { { p.SetState(3825) - p.Match(YQLv1Antlr4ParserEVALUATE) + p.Match(YQLParserEVALUATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68337,10 +68337,10 @@ func (p *YQLv1Antlr4Parser) For_stmt() (localctx IFor_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPARALLEL { + if _la == YQLParserPARALLEL { { p.SetState(3828) - p.Match(YQLv1Antlr4ParserPARALLEL) + p.Match(YQLParserPARALLEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68350,7 +68350,7 @@ func (p *YQLv1Antlr4Parser) For_stmt() (localctx IFor_stmtContext) { } { p.SetState(3831) - p.Match(YQLv1Antlr4ParserFOR) + p.Match(YQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68362,7 +68362,7 @@ func (p *YQLv1Antlr4Parser) For_stmt() (localctx IFor_stmtContext) { } { p.SetState(3833) - p.Match(YQLv1Antlr4ParserIN) + p.Match(YQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68384,10 +68384,10 @@ func (p *YQLv1Antlr4Parser) For_stmt() (localctx IFor_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserELSE { + if _la == YQLParserELSE { { p.SetState(3836) - p.Match(YQLv1Antlr4ParserELSE) + p.Match(YQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68453,13 +68453,13 @@ type Table_refContext struct { func NewEmptyTable_refContext() *Table_refContext { var p = new(Table_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_ref + p.RuleIndex = YQLParserRULE_table_ref return p } func InitEmptyTable_refContext(p *Table_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_ref + p.RuleIndex = YQLParserRULE_table_ref } func (*Table_refContext) IsTable_refContext() {} @@ -68470,7 +68470,7 @@ func NewTable_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_ref + p.RuleIndex = YQLParserRULE_table_ref return p } @@ -68510,11 +68510,11 @@ func (s *Table_refContext) An_id_expr() IAn_id_exprContext { } func (s *Table_refContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Table_refContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Table_refContext) Bind_parameter() IBind_parameterContext { @@ -68550,11 +68550,11 @@ func (s *Table_refContext) Cluster_expr() ICluster_exprContext { } func (s *Table_refContext) DOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, 0) + return s.GetToken(YQLParserDOT, 0) } func (s *Table_refContext) COMMAT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMAT, 0) + return s.GetToken(YQLParserCOMMAT, 0) } func (s *Table_refContext) Table_hints() ITable_hintsContext { @@ -68615,7 +68615,7 @@ func (s *Table_refContext) Table_arg(i int) ITable_argContext { } func (s *Table_refContext) VIEW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIEW, 0) + return s.GetToken(YQLParserVIEW, 0) } func (s *Table_refContext) View_name() IView_nameContext { @@ -68635,11 +68635,11 @@ func (s *Table_refContext) View_name() IView_nameContext { } func (s *Table_refContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Table_refContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Table_refContext) Expr_list() IExpr_listContext { @@ -68668,13 +68668,13 @@ func (s *Table_refContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Table_refContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_ref(s) } } func (s *Table_refContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_ref(s) } } @@ -68682,9 +68682,9 @@ func (s *Table_refContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { +func (p *YQLParser) Table_ref() (localctx ITable_refContext) { localctx = NewTable_refContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 638, YQLv1Antlr4ParserRULE_table_ref) + p.EnterRule(localctx, 638, YQLParserRULE_table_ref) var _la int var _alt int @@ -68701,7 +68701,7 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { } { p.SetState(3841) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68719,10 +68719,10 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMAT { + if _la == YQLParserCOMMAT { { p.SetState(3845) - p.Match(YQLv1Antlr4ParserCOMMAT) + p.Match(YQLParserCOMMAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68751,7 +68751,7 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { } { p.SetState(3850) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68783,7 +68783,7 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { if _alt == 1 { { p.SetState(3852) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68814,10 +68814,10 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3859) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68829,7 +68829,7 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { } { p.SetState(3864) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68850,10 +68850,10 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLPAREN { + if _la == YQLParserLPAREN { { p.SetState(3867) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68876,7 +68876,7 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { } { p.SetState(3871) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68892,10 +68892,10 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserVIEW { + if _la == YQLParserVIEW { { p.SetState(3874) - p.Match(YQLv1Antlr4ParserVIEW) + p.Match(YQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68919,7 +68919,7 @@ func (p *YQLv1Antlr4Parser) Table_ref() (localctx ITable_refContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(3880) p.Table_hints() @@ -68967,13 +68967,13 @@ type Table_keyContext struct { func NewEmptyTable_keyContext() *Table_keyContext { var p = new(Table_keyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_key + p.RuleIndex = YQLParserRULE_table_key return p } func InitEmptyTable_keyContext(p *Table_keyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_key + p.RuleIndex = YQLParserRULE_table_key } func (*Table_keyContext) IsTable_keyContext() {} @@ -68984,7 +68984,7 @@ func NewTable_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_key + p.RuleIndex = YQLParserRULE_table_key return p } @@ -69008,7 +69008,7 @@ func (s *Table_keyContext) Id_table_or_type() IId_table_or_typeContext { } func (s *Table_keyContext) VIEW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIEW, 0) + return s.GetToken(YQLParserVIEW, 0) } func (s *Table_keyContext) View_name() IView_nameContext { @@ -69037,13 +69037,13 @@ func (s *Table_keyContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Table_keyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_key(s) } } func (s *Table_keyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_key(s) } } @@ -69051,9 +69051,9 @@ func (s *Table_keyContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_key() (localctx ITable_keyContext) { +func (p *YQLParser) Table_key() (localctx ITable_keyContext) { localctx = NewTable_keyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 640, YQLv1Antlr4ParserRULE_table_key) + p.EnterRule(localctx, 640, YQLParserRULE_table_key) var _la int p.EnterOuterAlt(localctx, 1) @@ -69069,10 +69069,10 @@ func (p *YQLv1Antlr4Parser) Table_key() (localctx ITable_keyContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserVIEW { + if _la == YQLParserVIEW { { p.SetState(3884) - p.Match(YQLv1Antlr4ParserVIEW) + p.Match(YQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69126,13 +69126,13 @@ type Table_argContext struct { func NewEmptyTable_argContext() *Table_argContext { var p = new(Table_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_arg + p.RuleIndex = YQLParserRULE_table_arg return p } func InitEmptyTable_argContext(p *Table_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_arg + p.RuleIndex = YQLParserRULE_table_arg } func (*Table_argContext) IsTable_argContext() {} @@ -69143,7 +69143,7 @@ func NewTable_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_arg + p.RuleIndex = YQLParserRULE_table_arg return p } @@ -69167,11 +69167,11 @@ func (s *Table_argContext) Named_expr() INamed_exprContext { } func (s *Table_argContext) COMMAT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMAT, 0) + return s.GetToken(YQLParserCOMMAT, 0) } func (s *Table_argContext) VIEW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIEW, 0) + return s.GetToken(YQLParserVIEW, 0) } func (s *Table_argContext) View_name() IView_nameContext { @@ -69200,13 +69200,13 @@ func (s *Table_argContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Table_argContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_arg(s) } } func (s *Table_argContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_arg(s) } } @@ -69214,9 +69214,9 @@ func (s *Table_argContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_arg() (localctx ITable_argContext) { +func (p *YQLParser) Table_arg() (localctx ITable_argContext) { localctx = NewTable_argContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 642, YQLv1Antlr4ParserRULE_table_arg) + p.EnterRule(localctx, 642, YQLParserRULE_table_arg) var _la int p.EnterOuterAlt(localctx, 1) @@ -69228,10 +69228,10 @@ func (p *YQLv1Antlr4Parser) Table_arg() (localctx ITable_argContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMAT { + if _la == YQLParserCOMMAT { { p.SetState(3888) - p.Match(YQLv1Antlr4ParserCOMMAT) + p.Match(YQLParserCOMMAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69251,10 +69251,10 @@ func (p *YQLv1Antlr4Parser) Table_arg() (localctx ITable_argContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserVIEW { + if _la == YQLParserVIEW { { p.SetState(3892) - p.Match(YQLv1Antlr4ParserVIEW) + p.Match(YQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69311,13 +69311,13 @@ type Table_hintsContext struct { func NewEmptyTable_hintsContext() *Table_hintsContext { var p = new(Table_hintsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_hints + p.RuleIndex = YQLParserRULE_table_hints return p } func InitEmptyTable_hintsContext(p *Table_hintsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_hints + p.RuleIndex = YQLParserRULE_table_hints } func (*Table_hintsContext) IsTable_hintsContext() {} @@ -69328,7 +69328,7 @@ func NewTable_hintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_hints + p.RuleIndex = YQLParserRULE_table_hints return p } @@ -69336,7 +69336,7 @@ func NewTable_hintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Table_hintsContext) GetParser() antlr.Parser { return s.parser } func (s *Table_hintsContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Table_hintsContext) AllTable_hint() []ITable_hintContext { @@ -69381,19 +69381,19 @@ func (s *Table_hintsContext) Table_hint(i int) ITable_hintContext { } func (s *Table_hintsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Table_hintsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Table_hintsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Table_hintsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Table_hintsContext) GetRuleContext() antlr.RuleContext { @@ -69406,13 +69406,13 @@ func (s *Table_hintsContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Table_hintsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_hints(s) } } func (s *Table_hintsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_hints(s) } } @@ -69420,15 +69420,15 @@ func (s *Table_hintsContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_hints() (localctx ITable_hintsContext) { +func (p *YQLParser) Table_hints() (localctx ITable_hintsContext) { localctx = NewTable_hintsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 644, YQLv1Antlr4ParserRULE_table_hints) + p.EnterRule(localctx, 644, YQLParserRULE_table_hints) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3896) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69441,17 +69441,17 @@ func (p *YQLv1Antlr4Parser) Table_hints() (localctx ITable_hintsContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(3897) p.Table_hint() } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: { p.SetState(3898) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69469,10 +69469,10 @@ func (p *YQLv1Antlr4Parser) Table_hints() (localctx ITable_hintsContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(3900) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69493,7 +69493,7 @@ func (p *YQLv1Antlr4Parser) Table_hints() (localctx ITable_hintsContext) { } { p.SetState(3907) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69557,13 +69557,13 @@ type Table_hintContext struct { func NewEmptyTable_hintContext() *Table_hintContext { var p = new(Table_hintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_hint + p.RuleIndex = YQLParserRULE_table_hint return p } func InitEmptyTable_hintContext(p *Table_hintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_table_hint + p.RuleIndex = YQLParserRULE_table_hint } func (*Table_hintContext) IsTable_hintContext() {} @@ -69574,7 +69574,7 @@ func NewTable_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_table_hint + p.RuleIndex = YQLParserRULE_table_hint return p } @@ -69598,7 +69598,7 @@ func (s *Table_hintContext) An_id_hint() IAn_id_hintContext { } func (s *Table_hintContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Table_hintContext) AllType_name_tag() []IType_name_tagContext { @@ -69643,19 +69643,19 @@ func (s *Table_hintContext) Type_name_tag(i int) IType_name_tagContext { } func (s *Table_hintContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Table_hintContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Table_hintContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Table_hintContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Table_hintContext) Type_name_or_bind() IType_name_or_bindContext { @@ -69675,11 +69675,11 @@ func (s *Table_hintContext) Type_name_or_bind() IType_name_or_bindContext { } func (s *Table_hintContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSCHEMA, 0) + return s.GetToken(YQLParserSCHEMA, 0) } func (s *Table_hintContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMNS, 0) + return s.GetToken(YQLParserCOLUMNS, 0) } func (s *Table_hintContext) AllStruct_arg_positional() []IStruct_arg_positionalContext { @@ -69733,13 +69733,13 @@ func (s *Table_hintContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Table_hintContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTable_hint(s) } } func (s *Table_hintContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTable_hint(s) } } @@ -69747,9 +69747,9 @@ func (s *Table_hintContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { +func (p *YQLParser) Table_hint() (localctx ITable_hintContext) { localctx = NewTable_hintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 646, YQLv1Antlr4ParserRULE_table_hint) + p.EnterRule(localctx, 646, YQLParserRULE_table_hint) var _la int var _alt int @@ -69775,10 +69775,10 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEQUALS { + if _la == YQLParserEQUALS { { p.SetState(3912) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69791,17 +69791,17 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDOLLAR, YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserDOLLAR, YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(3913) p.Type_name_tag() } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: { p.SetState(3914) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69824,7 +69824,7 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { if _alt == 1 { { p.SetState(3916) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69855,10 +69855,10 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3923) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69868,7 +69868,7 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { } { p.SetState(3926) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69891,7 +69891,7 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { p.SetState(3932) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserCOLUMNS || _la == YQLv1Antlr4ParserSCHEMA) { + if !(_la == YQLParserCOLUMNS || _la == YQLParserSCHEMA) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -69906,10 +69906,10 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEQUALS { + if _la == YQLParserEQUALS { { p.SetState(3933) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69927,7 +69927,7 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(3937) - p.Match(YQLv1Antlr4ParserSCHEMA) + p.Match(YQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69941,10 +69941,10 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEQUALS { + if _la == YQLParserEQUALS { { p.SetState(3938) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69954,7 +69954,7 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { } { p.SetState(3941) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69986,7 +69986,7 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { if _alt == 1 { { p.SetState(3943) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70019,10 +70019,10 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(3952) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70032,7 +70032,7 @@ func (p *YQLv1Antlr4Parser) Table_hint() (localctx ITable_hintContext) { } { p.SetState(3955) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70082,13 +70082,13 @@ type Object_refContext struct { func NewEmptyObject_refContext() *Object_refContext { var p = new(Object_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_ref + p.RuleIndex = YQLParserRULE_object_ref return p } func InitEmptyObject_refContext(p *Object_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_object_ref + p.RuleIndex = YQLParserRULE_object_ref } func (*Object_refContext) IsObject_refContext() {} @@ -70099,7 +70099,7 @@ func NewObject_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_object_ref + p.RuleIndex = YQLParserRULE_object_ref return p } @@ -70139,7 +70139,7 @@ func (s *Object_refContext) Cluster_expr() ICluster_exprContext { } func (s *Object_refContext) DOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, 0) + return s.GetToken(YQLParserDOT, 0) } func (s *Object_refContext) GetRuleContext() antlr.RuleContext { @@ -70152,13 +70152,13 @@ func (s *Object_refContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Object_refContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterObject_ref(s) } } func (s *Object_refContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitObject_ref(s) } } @@ -70166,9 +70166,9 @@ func (s *Object_refContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Object_ref() (localctx IObject_refContext) { +func (p *YQLParser) Object_ref() (localctx IObject_refContext) { localctx = NewObject_refContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 648, YQLv1Antlr4ParserRULE_object_ref) + p.EnterRule(localctx, 648, YQLParserRULE_object_ref) p.EnterOuterAlt(localctx, 1) p.SetState(3961) p.GetErrorHandler().Sync(p) @@ -70181,7 +70181,7 @@ func (p *YQLv1Antlr4Parser) Object_ref() (localctx IObject_refContext) { } { p.SetState(3959) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70236,13 +70236,13 @@ type Simple_table_ref_coreContext struct { func NewEmptySimple_table_ref_coreContext() *Simple_table_ref_coreContext { var p = new(Simple_table_ref_coreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_table_ref_core + p.RuleIndex = YQLParserRULE_simple_table_ref_core return p } func InitEmptySimple_table_ref_coreContext(p *Simple_table_ref_coreContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_table_ref_core + p.RuleIndex = YQLParserRULE_simple_table_ref_core } func (*Simple_table_ref_coreContext) IsSimple_table_ref_coreContext() {} @@ -70253,7 +70253,7 @@ func NewSimple_table_ref_coreContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_table_ref_core + p.RuleIndex = YQLParserRULE_simple_table_ref_core return p } @@ -70293,7 +70293,7 @@ func (s *Simple_table_ref_coreContext) Bind_parameter() IBind_parameterContext { } func (s *Simple_table_ref_coreContext) COMMAT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMAT, 0) + return s.GetToken(YQLParserCOMMAT, 0) } func (s *Simple_table_ref_coreContext) GetRuleContext() antlr.RuleContext { @@ -70306,13 +70306,13 @@ func (s *Simple_table_ref_coreContext) ToStringTree(ruleNames []string, recog an func (s *Simple_table_ref_coreContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSimple_table_ref_core(s) } } func (s *Simple_table_ref_coreContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSimple_table_ref_core(s) } } @@ -70320,9 +70320,9 @@ func (s *Simple_table_ref_coreContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Simple_table_ref_core() (localctx ISimple_table_ref_coreContext) { +func (p *YQLParser) Simple_table_ref_core() (localctx ISimple_table_ref_coreContext) { localctx = NewSimple_table_ref_coreContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 650, YQLv1Antlr4ParserRULE_simple_table_ref_core) + p.EnterRule(localctx, 650, YQLParserRULE_simple_table_ref_core) var _la int p.SetState(3970) @@ -70350,10 +70350,10 @@ func (p *YQLv1Antlr4Parser) Simple_table_ref_core() (localctx ISimple_table_ref_ _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMAT { + if _la == YQLParserCOMMAT { { p.SetState(3966) - p.Match(YQLv1Antlr4ParserCOMMAT) + p.Match(YQLParserCOMMAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70408,13 +70408,13 @@ type Simple_table_refContext struct { func NewEmptySimple_table_refContext() *Simple_table_refContext { var p = new(Simple_table_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_table_ref + p.RuleIndex = YQLParserRULE_simple_table_ref return p } func InitEmptySimple_table_refContext(p *Simple_table_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_table_ref + p.RuleIndex = YQLParserRULE_simple_table_ref } func (*Simple_table_refContext) IsSimple_table_refContext() {} @@ -70425,7 +70425,7 @@ func NewSimple_table_refContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_simple_table_ref + p.RuleIndex = YQLParserRULE_simple_table_ref return p } @@ -70474,13 +70474,13 @@ func (s *Simple_table_refContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Simple_table_refContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSimple_table_ref(s) } } func (s *Simple_table_refContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSimple_table_ref(s) } } @@ -70488,9 +70488,9 @@ func (s *Simple_table_refContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Simple_table_ref() (localctx ISimple_table_refContext) { +func (p *YQLParser) Simple_table_ref() (localctx ISimple_table_refContext) { localctx = NewSimple_table_refContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 652, YQLv1Antlr4ParserRULE_simple_table_ref) + p.EnterRule(localctx, 652, YQLParserRULE_simple_table_ref) var _la int p.EnterOuterAlt(localctx, 1) @@ -70506,7 +70506,7 @@ func (p *YQLv1Antlr4Parser) Simple_table_ref() (localctx ISimple_table_refContex _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(3973) p.Table_hints() @@ -70555,13 +70555,13 @@ type Into_simple_table_refContext struct { func NewEmptyInto_simple_table_refContext() *Into_simple_table_refContext { var p = new(Into_simple_table_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_into_simple_table_ref + p.RuleIndex = YQLParserRULE_into_simple_table_ref return p } func InitEmptyInto_simple_table_refContext(p *Into_simple_table_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_into_simple_table_ref + p.RuleIndex = YQLParserRULE_into_simple_table_ref } func (*Into_simple_table_refContext) IsInto_simple_table_refContext() {} @@ -70572,7 +70572,7 @@ func NewInto_simple_table_refContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_into_simple_table_ref + p.RuleIndex = YQLParserRULE_into_simple_table_ref return p } @@ -70596,11 +70596,11 @@ func (s *Into_simple_table_refContext) Simple_table_ref() ISimple_table_refConte } func (s *Into_simple_table_refContext) ERASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERASE, 0) + return s.GetToken(YQLParserERASE, 0) } func (s *Into_simple_table_refContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Into_simple_table_refContext) Pure_column_list() IPure_column_listContext { @@ -70629,13 +70629,13 @@ func (s *Into_simple_table_refContext) ToStringTree(ruleNames []string, recog an func (s *Into_simple_table_refContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInto_simple_table_ref(s) } } func (s *Into_simple_table_refContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInto_simple_table_ref(s) } } @@ -70643,9 +70643,9 @@ func (s *Into_simple_table_refContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Into_simple_table_ref() (localctx IInto_simple_table_refContext) { +func (p *YQLParser) Into_simple_table_ref() (localctx IInto_simple_table_refContext) { localctx = NewInto_simple_table_refContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 654, YQLv1Antlr4ParserRULE_into_simple_table_ref) + p.EnterRule(localctx, 654, YQLParserRULE_into_simple_table_ref) var _la int p.EnterOuterAlt(localctx, 1) @@ -70661,10 +70661,10 @@ func (p *YQLv1Antlr4Parser) Into_simple_table_ref() (localctx IInto_simple_table _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserERASE { + if _la == YQLParserERASE { { p.SetState(3977) - p.Match(YQLv1Antlr4ParserERASE) + p.Match(YQLParserERASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70672,7 +70672,7 @@ func (p *YQLv1Antlr4Parser) Into_simple_table_ref() (localctx IInto_simple_table } { p.SetState(3978) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70730,13 +70730,13 @@ type Delete_stmtContext struct { func NewEmptyDelete_stmtContext() *Delete_stmtContext { var p = new(Delete_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_delete_stmt + p.RuleIndex = YQLParserRULE_delete_stmt return p } func InitEmptyDelete_stmtContext(p *Delete_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_delete_stmt + p.RuleIndex = YQLParserRULE_delete_stmt } func (*Delete_stmtContext) IsDelete_stmtContext() {} @@ -70747,7 +70747,7 @@ func NewDelete_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_delete_stmt + p.RuleIndex = YQLParserRULE_delete_stmt return p } @@ -70755,11 +70755,11 @@ func NewDelete_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Delete_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Delete_stmtContext) DELETE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDELETE, 0) + return s.GetToken(YQLParserDELETE, 0) } func (s *Delete_stmtContext) FROM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFROM, 0) + return s.GetToken(YQLParserFROM, 0) } func (s *Delete_stmtContext) Simple_table_ref() ISimple_table_refContext { @@ -70779,7 +70779,7 @@ func (s *Delete_stmtContext) Simple_table_ref() ISimple_table_refContext { } func (s *Delete_stmtContext) WHERE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHERE, 0) + return s.GetToken(YQLParserWHERE, 0) } func (s *Delete_stmtContext) Expr() IExprContext { @@ -70799,7 +70799,7 @@ func (s *Delete_stmtContext) Expr() IExprContext { } func (s *Delete_stmtContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Delete_stmtContext) Into_values_source() IInto_values_sourceContext { @@ -70844,13 +70844,13 @@ func (s *Delete_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Delete_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDelete_stmt(s) } } func (s *Delete_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDelete_stmt(s) } } @@ -70858,15 +70858,15 @@ func (s *Delete_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Delete_stmt() (localctx IDelete_stmtContext) { +func (p *YQLParser) Delete_stmt() (localctx IDelete_stmtContext) { localctx = NewDelete_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 656, YQLv1Antlr4ParserRULE_delete_stmt) + p.EnterRule(localctx, 656, YQLParserRULE_delete_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3982) - p.Match(YQLv1Antlr4ParserDELETE) + p.Match(YQLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70874,7 +70874,7 @@ func (p *YQLv1Antlr4Parser) Delete_stmt() (localctx IDelete_stmtContext) { } { p.SetState(3983) - p.Match(YQLv1Antlr4ParserFROM) + p.Match(YQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70890,10 +70890,10 @@ func (p *YQLv1Antlr4Parser) Delete_stmt() (localctx IDelete_stmtContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserWHERE: + case YQLParserWHERE: { p.SetState(3985) - p.Match(YQLv1Antlr4ParserWHERE) + p.Match(YQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70905,10 +70905,10 @@ func (p *YQLv1Antlr4Parser) Delete_stmt() (localctx IDelete_stmtContext) { } - case YQLv1Antlr4ParserON: + case YQLParserON: { p.SetState(3987) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70920,7 +70920,7 @@ func (p *YQLv1Antlr4Parser) Delete_stmt() (localctx IDelete_stmtContext) { } - case YQLv1Antlr4ParserEOF, YQLv1Antlr4ParserSEMICOLON, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserRETURNING: + case YQLParserEOF, YQLParserSEMICOLON, YQLParserEND, YQLParserRETURNING: @@ -70934,7 +70934,7 @@ func (p *YQLv1Antlr4Parser) Delete_stmt() (localctx IDelete_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserRETURNING { + if _la == YQLParserRETURNING { { p.SetState(3991) p.Returning_columns_list() @@ -70988,13 +70988,13 @@ type Update_stmtContext struct { func NewEmptyUpdate_stmtContext() *Update_stmtContext { var p = new(Update_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_update_stmt + p.RuleIndex = YQLParserRULE_update_stmt return p } func InitEmptyUpdate_stmtContext(p *Update_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_update_stmt + p.RuleIndex = YQLParserRULE_update_stmt } func (*Update_stmtContext) IsUpdate_stmtContext() {} @@ -71005,7 +71005,7 @@ func NewUpdate_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_update_stmt + p.RuleIndex = YQLParserRULE_update_stmt return p } @@ -71013,7 +71013,7 @@ func NewUpdate_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Update_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Update_stmtContext) UPDATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPDATE, 0) + return s.GetToken(YQLParserUPDATE, 0) } func (s *Update_stmtContext) Simple_table_ref() ISimple_table_refContext { @@ -71033,7 +71033,7 @@ func (s *Update_stmtContext) Simple_table_ref() ISimple_table_refContext { } func (s *Update_stmtContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Update_stmtContext) Set_clause_choice() ISet_clause_choiceContext { @@ -71053,7 +71053,7 @@ func (s *Update_stmtContext) Set_clause_choice() ISet_clause_choiceContext { } func (s *Update_stmtContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Update_stmtContext) Into_values_source() IInto_values_sourceContext { @@ -71089,7 +71089,7 @@ func (s *Update_stmtContext) Returning_columns_list() IReturning_columns_listCon } func (s *Update_stmtContext) WHERE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHERE, 0) + return s.GetToken(YQLParserWHERE, 0) } func (s *Update_stmtContext) Expr() IExprContext { @@ -71118,13 +71118,13 @@ func (s *Update_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Update_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUpdate_stmt(s) } } func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUpdate_stmt(s) } } @@ -71132,15 +71132,15 @@ func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Update_stmt() (localctx IUpdate_stmtContext) { +func (p *YQLParser) Update_stmt() (localctx IUpdate_stmtContext) { localctx = NewUpdate_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 658, YQLv1Antlr4ParserRULE_update_stmt) + p.EnterRule(localctx, 658, YQLParserRULE_update_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3994) - p.Match(YQLv1Antlr4ParserUPDATE) + p.Match(YQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71157,10 +71157,10 @@ func (p *YQLv1Antlr4Parser) Update_stmt() (localctx IUpdate_stmtContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSET: + case YQLParserSET: { p.SetState(3996) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71178,10 +71178,10 @@ func (p *YQLv1Antlr4Parser) Update_stmt() (localctx IUpdate_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWHERE { + if _la == YQLParserWHERE { { p.SetState(3998) - p.Match(YQLv1Antlr4ParserWHERE) + p.Match(YQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71195,10 +71195,10 @@ func (p *YQLv1Antlr4Parser) Update_stmt() (localctx IUpdate_stmtContext) { } - case YQLv1Antlr4ParserON: + case YQLParserON: { p.SetState(4002) - p.Match(YQLv1Antlr4ParserON) + p.Match(YQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71223,7 +71223,7 @@ func (p *YQLv1Antlr4Parser) Update_stmt() (localctx IUpdate_stmtContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserRETURNING { + if _la == YQLParserRETURNING { { p.SetState(4006) p.Returning_columns_list() @@ -71270,13 +71270,13 @@ type Set_clause_choiceContext struct { func NewEmptySet_clause_choiceContext() *Set_clause_choiceContext { var p = new(Set_clause_choiceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause_choice + p.RuleIndex = YQLParserRULE_set_clause_choice return p } func InitEmptySet_clause_choiceContext(p *Set_clause_choiceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause_choice + p.RuleIndex = YQLParserRULE_set_clause_choice } func (*Set_clause_choiceContext) IsSet_clause_choiceContext() {} @@ -71287,7 +71287,7 @@ func NewSet_clause_choiceContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause_choice + p.RuleIndex = YQLParserRULE_set_clause_choice return p } @@ -71336,13 +71336,13 @@ func (s *Set_clause_choiceContext) ToStringTree(ruleNames []string, recog antlr. func (s *Set_clause_choiceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSet_clause_choice(s) } } func (s *Set_clause_choiceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSet_clause_choice(s) } } @@ -71350,9 +71350,9 @@ func (s *Set_clause_choiceContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Set_clause_choice() (localctx ISet_clause_choiceContext) { +func (p *YQLParser) Set_clause_choice() (localctx ISet_clause_choiceContext) { localctx = NewSet_clause_choiceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 660, YQLv1Antlr4ParserRULE_set_clause_choice) + p.EnterRule(localctx, 660, YQLParserRULE_set_clause_choice) p.SetState(4011) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -71360,7 +71360,7 @@ func (p *YQLv1Antlr4Parser) Set_clause_choice() (localctx ISet_clause_choiceCont } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4009) @@ -71368,7 +71368,7 @@ func (p *YQLv1Antlr4Parser) Set_clause_choice() (localctx ISet_clause_choiceCont } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(4010) @@ -71422,13 +71422,13 @@ type Set_clause_listContext struct { func NewEmptySet_clause_listContext() *Set_clause_listContext { var p = new(Set_clause_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause_list + p.RuleIndex = YQLParserRULE_set_clause_list return p } func InitEmptySet_clause_listContext(p *Set_clause_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause_list + p.RuleIndex = YQLParserRULE_set_clause_list } func (*Set_clause_listContext) IsSet_clause_listContext() {} @@ -71439,7 +71439,7 @@ func NewSet_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause_list + p.RuleIndex = YQLParserRULE_set_clause_list return p } @@ -71488,11 +71488,11 @@ func (s *Set_clause_listContext) Set_clause(i int) ISet_clauseContext { } func (s *Set_clause_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Set_clause_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Set_clause_listContext) GetRuleContext() antlr.RuleContext { @@ -71505,13 +71505,13 @@ func (s *Set_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Set_clause_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSet_clause_list(s) } } func (s *Set_clause_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSet_clause_list(s) } } @@ -71519,9 +71519,9 @@ func (s *Set_clause_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Set_clause_list() (localctx ISet_clause_listContext) { +func (p *YQLParser) Set_clause_list() (localctx ISet_clause_listContext) { localctx = NewSet_clause_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 662, YQLv1Antlr4ParserRULE_set_clause_list) + p.EnterRule(localctx, 662, YQLParserRULE_set_clause_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -71537,10 +71537,10 @@ func (p *YQLv1Antlr4Parser) Set_clause_list() (localctx ISet_clause_listContext) _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4014) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71600,13 +71600,13 @@ type Set_clauseContext struct { func NewEmptySet_clauseContext() *Set_clauseContext { var p = new(Set_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause + p.RuleIndex = YQLParserRULE_set_clause return p } func InitEmptySet_clauseContext(p *Set_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause + p.RuleIndex = YQLParserRULE_set_clause } func (*Set_clauseContext) IsSet_clauseContext() {} @@ -71617,7 +71617,7 @@ func NewSet_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_set_clause + p.RuleIndex = YQLParserRULE_set_clause return p } @@ -71641,7 +71641,7 @@ func (s *Set_clauseContext) Set_target() ISet_targetContext { } func (s *Set_clauseContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Set_clauseContext) Expr() IExprContext { @@ -71670,13 +71670,13 @@ func (s *Set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSet_clause(s) } } func (s *Set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSet_clause(s) } } @@ -71684,9 +71684,9 @@ func (s *Set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Set_clause() (localctx ISet_clauseContext) { +func (p *YQLParser) Set_clause() (localctx ISet_clauseContext) { localctx = NewSet_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 664, YQLv1Antlr4ParserRULE_set_clause) + p.EnterRule(localctx, 664, YQLParserRULE_set_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(4021) @@ -71694,7 +71694,7 @@ func (p *YQLv1Antlr4Parser) Set_clause() (localctx ISet_clauseContext) { } { p.SetState(4022) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71743,13 +71743,13 @@ type Set_targetContext struct { func NewEmptySet_targetContext() *Set_targetContext { var p = new(Set_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_target + p.RuleIndex = YQLParserRULE_set_target return p } func InitEmptySet_targetContext(p *Set_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_target + p.RuleIndex = YQLParserRULE_set_target } func (*Set_targetContext) IsSet_targetContext() {} @@ -71760,7 +71760,7 @@ func NewSet_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_set_target + p.RuleIndex = YQLParserRULE_set_target return p } @@ -71793,13 +71793,13 @@ func (s *Set_targetContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Set_targetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSet_target(s) } } func (s *Set_targetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSet_target(s) } } @@ -71807,9 +71807,9 @@ func (s *Set_targetContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Set_target() (localctx ISet_targetContext) { +func (p *YQLParser) Set_target() (localctx ISet_targetContext) { localctx = NewSet_targetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 666, YQLv1Antlr4ParserRULE_set_target) + p.EnterRule(localctx, 666, YQLParserRULE_set_target) p.EnterOuterAlt(localctx, 1) { p.SetState(4025) @@ -71858,13 +71858,13 @@ type Multiple_column_assignmentContext struct { func NewEmptyMultiple_column_assignmentContext() *Multiple_column_assignmentContext { var p = new(Multiple_column_assignmentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_multiple_column_assignment + p.RuleIndex = YQLParserRULE_multiple_column_assignment return p } func InitEmptyMultiple_column_assignmentContext(p *Multiple_column_assignmentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_multiple_column_assignment + p.RuleIndex = YQLParserRULE_multiple_column_assignment } func (*Multiple_column_assignmentContext) IsMultiple_column_assignmentContext() {} @@ -71875,7 +71875,7 @@ func NewMultiple_column_assignmentContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_multiple_column_assignment + p.RuleIndex = YQLParserRULE_multiple_column_assignment return p } @@ -71899,11 +71899,11 @@ func (s *Multiple_column_assignmentContext) Set_target_list() ISet_target_listCo } func (s *Multiple_column_assignmentContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Multiple_column_assignmentContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Multiple_column_assignmentContext) Simple_values_source() ISimple_values_sourceContext { @@ -71923,7 +71923,7 @@ func (s *Multiple_column_assignmentContext) Simple_values_source() ISimple_value } func (s *Multiple_column_assignmentContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Multiple_column_assignmentContext) GetRuleContext() antlr.RuleContext { @@ -71936,13 +71936,13 @@ func (s *Multiple_column_assignmentContext) ToStringTree(ruleNames []string, rec func (s *Multiple_column_assignmentContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterMultiple_column_assignment(s) } } func (s *Multiple_column_assignmentContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitMultiple_column_assignment(s) } } @@ -71950,9 +71950,9 @@ func (s *Multiple_column_assignmentContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Multiple_column_assignment() (localctx IMultiple_column_assignmentContext) { +func (p *YQLParser) Multiple_column_assignment() (localctx IMultiple_column_assignmentContext) { localctx = NewMultiple_column_assignmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 668, YQLv1Antlr4ParserRULE_multiple_column_assignment) + p.EnterRule(localctx, 668, YQLParserRULE_multiple_column_assignment) p.EnterOuterAlt(localctx, 1) { p.SetState(4027) @@ -71960,7 +71960,7 @@ func (p *YQLv1Antlr4Parser) Multiple_column_assignment() (localctx IMultiple_col } { p.SetState(4028) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71968,7 +71968,7 @@ func (p *YQLv1Antlr4Parser) Multiple_column_assignment() (localctx IMultiple_col } { p.SetState(4029) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71980,7 +71980,7 @@ func (p *YQLv1Antlr4Parser) Multiple_column_assignment() (localctx IMultiple_col } { p.SetState(4031) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72030,13 +72030,13 @@ type Set_target_listContext struct { func NewEmptySet_target_listContext() *Set_target_listContext { var p = new(Set_target_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_target_list + p.RuleIndex = YQLParserRULE_set_target_list return p } func InitEmptySet_target_listContext(p *Set_target_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_set_target_list + p.RuleIndex = YQLParserRULE_set_target_list } func (*Set_target_listContext) IsSet_target_listContext() {} @@ -72047,7 +72047,7 @@ func NewSet_target_listContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_set_target_list + p.RuleIndex = YQLParserRULE_set_target_list return p } @@ -72055,7 +72055,7 @@ func NewSet_target_listContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Set_target_listContext) GetParser() antlr.Parser { return s.parser } func (s *Set_target_listContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Set_target_listContext) AllSet_target() []ISet_targetContext { @@ -72100,15 +72100,15 @@ func (s *Set_target_listContext) Set_target(i int) ISet_targetContext { } func (s *Set_target_listContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Set_target_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Set_target_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Set_target_listContext) GetRuleContext() antlr.RuleContext { @@ -72121,13 +72121,13 @@ func (s *Set_target_listContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Set_target_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSet_target_list(s) } } func (s *Set_target_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSet_target_list(s) } } @@ -72135,15 +72135,15 @@ func (s *Set_target_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Set_target_list() (localctx ISet_target_listContext) { +func (p *YQLParser) Set_target_list() (localctx ISet_target_listContext) { localctx = NewSet_target_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 670, YQLv1Antlr4ParserRULE_set_target_list) + p.EnterRule(localctx, 670, YQLParserRULE_set_target_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4033) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72161,10 +72161,10 @@ func (p *YQLv1Antlr4Parser) Set_target_list() (localctx ISet_target_listContext) _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4035) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72185,7 +72185,7 @@ func (p *YQLv1Antlr4Parser) Set_target_list() (localctx ISet_target_listContext) } { p.SetState(4042) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72237,13 +72237,13 @@ type Create_topic_stmtContext struct { func NewEmptyCreate_topic_stmtContext() *Create_topic_stmtContext { var p = new(Create_topic_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_stmt + p.RuleIndex = YQLParserRULE_create_topic_stmt return p } func InitEmptyCreate_topic_stmtContext(p *Create_topic_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_stmt + p.RuleIndex = YQLParserRULE_create_topic_stmt } func (*Create_topic_stmtContext) IsCreate_topic_stmtContext() {} @@ -72254,7 +72254,7 @@ func NewCreate_topic_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_stmt + p.RuleIndex = YQLParserRULE_create_topic_stmt return p } @@ -72262,11 +72262,11 @@ func NewCreate_topic_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Create_topic_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Create_topic_stmtContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Create_topic_stmtContext) TOPIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTOPIC, 0) + return s.GetToken(YQLParserTOPIC, 0) } func (s *Create_topic_stmtContext) Topic_ref() ITopic_refContext { @@ -72286,15 +72286,15 @@ func (s *Create_topic_stmtContext) Topic_ref() ITopic_refContext { } func (s *Create_topic_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Create_topic_stmtContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Create_topic_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Create_topic_stmtContext) Create_topic_entries() ICreate_topic_entriesContext { @@ -72339,13 +72339,13 @@ func (s *Create_topic_stmtContext) ToStringTree(ruleNames []string, recog antlr. func (s *Create_topic_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_topic_stmt(s) } } func (s *Create_topic_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_topic_stmt(s) } } @@ -72353,15 +72353,15 @@ func (s *Create_topic_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_topic_stmt() (localctx ICreate_topic_stmtContext) { +func (p *YQLParser) Create_topic_stmt() (localctx ICreate_topic_stmtContext) { localctx = NewCreate_topic_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 672, YQLv1Antlr4ParserRULE_create_topic_stmt) + p.EnterRule(localctx, 672, YQLParserRULE_create_topic_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4044) - p.Match(YQLv1Antlr4ParserCREATE) + p.Match(YQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72369,7 +72369,7 @@ func (p *YQLv1Antlr4Parser) Create_topic_stmt() (localctx ICreate_topic_stmtCont } { p.SetState(4045) - p.Match(YQLv1Antlr4ParserTOPIC) + p.Match(YQLParserTOPIC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72382,7 +72382,7 @@ func (p *YQLv1Antlr4Parser) Create_topic_stmt() (localctx ICreate_topic_stmtCont if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 436, p.GetParserRuleContext()) == 1 { { p.SetState(4046) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72390,7 +72390,7 @@ func (p *YQLv1Antlr4Parser) Create_topic_stmt() (localctx ICreate_topic_stmtCont } { p.SetState(4047) - p.Match(YQLv1Antlr4ParserNOT) + p.Match(YQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72398,7 +72398,7 @@ func (p *YQLv1Antlr4Parser) Create_topic_stmt() (localctx ICreate_topic_stmtCont } { p.SetState(4048) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72420,7 +72420,7 @@ func (p *YQLv1Antlr4Parser) Create_topic_stmt() (localctx ICreate_topic_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLPAREN { + if _la == YQLParserLPAREN { { p.SetState(4052) p.Create_topic_entries() @@ -72435,7 +72435,7 @@ func (p *YQLv1Antlr4Parser) Create_topic_stmt() (localctx ICreate_topic_stmtCont _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(4055) p.With_topic_settings() @@ -72486,13 +72486,13 @@ type Create_topic_entriesContext struct { func NewEmptyCreate_topic_entriesContext() *Create_topic_entriesContext { var p = new(Create_topic_entriesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_entries + p.RuleIndex = YQLParserRULE_create_topic_entries return p } func InitEmptyCreate_topic_entriesContext(p *Create_topic_entriesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_entries + p.RuleIndex = YQLParserRULE_create_topic_entries } func (*Create_topic_entriesContext) IsCreate_topic_entriesContext() {} @@ -72503,7 +72503,7 @@ func NewCreate_topic_entriesContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_entries + p.RuleIndex = YQLParserRULE_create_topic_entries return p } @@ -72511,7 +72511,7 @@ func NewCreate_topic_entriesContext(parser antlr.Parser, parent antlr.ParserRule func (s *Create_topic_entriesContext) GetParser() antlr.Parser { return s.parser } func (s *Create_topic_entriesContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Create_topic_entriesContext) AllCreate_topic_entry() []ICreate_topic_entryContext { @@ -72556,15 +72556,15 @@ func (s *Create_topic_entriesContext) Create_topic_entry(i int) ICreate_topic_en } func (s *Create_topic_entriesContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Create_topic_entriesContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Create_topic_entriesContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Create_topic_entriesContext) GetRuleContext() antlr.RuleContext { @@ -72577,13 +72577,13 @@ func (s *Create_topic_entriesContext) ToStringTree(ruleNames []string, recog ant func (s *Create_topic_entriesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_topic_entries(s) } } func (s *Create_topic_entriesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_topic_entries(s) } } @@ -72591,15 +72591,15 @@ func (s *Create_topic_entriesContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Create_topic_entries() (localctx ICreate_topic_entriesContext) { +func (p *YQLParser) Create_topic_entries() (localctx ICreate_topic_entriesContext) { localctx = NewCreate_topic_entriesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 674, YQLv1Antlr4ParserRULE_create_topic_entries) + p.EnterRule(localctx, 674, YQLParserRULE_create_topic_entries) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4058) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72617,10 +72617,10 @@ func (p *YQLv1Antlr4Parser) Create_topic_entries() (localctx ICreate_topic_entri _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4060) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72641,7 +72641,7 @@ func (p *YQLv1Antlr4Parser) Create_topic_entries() (localctx ICreate_topic_entri } { p.SetState(4067) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72686,13 +72686,13 @@ type Create_topic_entryContext struct { func NewEmptyCreate_topic_entryContext() *Create_topic_entryContext { var p = new(Create_topic_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_entry + p.RuleIndex = YQLParserRULE_create_topic_entry return p } func InitEmptyCreate_topic_entryContext(p *Create_topic_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_entry + p.RuleIndex = YQLParserRULE_create_topic_entry } func (*Create_topic_entryContext) IsCreate_topic_entryContext() {} @@ -72703,7 +72703,7 @@ func NewCreate_topic_entryContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_create_topic_entry + p.RuleIndex = YQLParserRULE_create_topic_entry return p } @@ -72736,13 +72736,13 @@ func (s *Create_topic_entryContext) ToStringTree(ruleNames []string, recog antlr func (s *Create_topic_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCreate_topic_entry(s) } } func (s *Create_topic_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCreate_topic_entry(s) } } @@ -72750,9 +72750,9 @@ func (s *Create_topic_entryContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Create_topic_entry() (localctx ICreate_topic_entryContext) { +func (p *YQLParser) Create_topic_entry() (localctx ICreate_topic_entryContext) { localctx = NewCreate_topic_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 676, YQLv1Antlr4ParserRULE_create_topic_entry) + p.EnterRule(localctx, 676, YQLParserRULE_create_topic_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(4069) @@ -72800,13 +72800,13 @@ type With_topic_settingsContext struct { func NewEmptyWith_topic_settingsContext() *With_topic_settingsContext { var p = new(With_topic_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_with_topic_settings + p.RuleIndex = YQLParserRULE_with_topic_settings return p } func InitEmptyWith_topic_settingsContext(p *With_topic_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_with_topic_settings + p.RuleIndex = YQLParserRULE_with_topic_settings } func (*With_topic_settingsContext) IsWith_topic_settingsContext() {} @@ -72817,7 +72817,7 @@ func NewWith_topic_settingsContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_with_topic_settings + p.RuleIndex = YQLParserRULE_with_topic_settings return p } @@ -72825,11 +72825,11 @@ func NewWith_topic_settingsContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *With_topic_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *With_topic_settingsContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *With_topic_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *With_topic_settingsContext) Topic_settings() ITopic_settingsContext { @@ -72849,7 +72849,7 @@ func (s *With_topic_settingsContext) Topic_settings() ITopic_settingsContext { } func (s *With_topic_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *With_topic_settingsContext) GetRuleContext() antlr.RuleContext { @@ -72862,13 +72862,13 @@ func (s *With_topic_settingsContext) ToStringTree(ruleNames []string, recog antl func (s *With_topic_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWith_topic_settings(s) } } func (s *With_topic_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWith_topic_settings(s) } } @@ -72876,13 +72876,13 @@ func (s *With_topic_settingsContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) With_topic_settings() (localctx IWith_topic_settingsContext) { +func (p *YQLParser) With_topic_settings() (localctx IWith_topic_settingsContext) { localctx = NewWith_topic_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 678, YQLv1Antlr4ParserRULE_with_topic_settings) + p.EnterRule(localctx, 678, YQLParserRULE_with_topic_settings) p.EnterOuterAlt(localctx, 1) { p.SetState(4071) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72890,7 +72890,7 @@ func (p *YQLv1Antlr4Parser) With_topic_settings() (localctx IWith_topic_settings } { p.SetState(4072) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72902,7 +72902,7 @@ func (p *YQLv1Antlr4Parser) With_topic_settings() (localctx IWith_topic_settings } { p.SetState(4074) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72955,13 +72955,13 @@ type Alter_topic_stmtContext struct { func NewEmptyAlter_topic_stmtContext() *Alter_topic_stmtContext { var p = new(Alter_topic_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_stmt + p.RuleIndex = YQLParserRULE_alter_topic_stmt return p } func InitEmptyAlter_topic_stmtContext(p *Alter_topic_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_stmt + p.RuleIndex = YQLParserRULE_alter_topic_stmt } func (*Alter_topic_stmtContext) IsAlter_topic_stmtContext() {} @@ -72972,7 +72972,7 @@ func NewAlter_topic_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_stmt + p.RuleIndex = YQLParserRULE_alter_topic_stmt return p } @@ -72980,11 +72980,11 @@ func NewAlter_topic_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *Alter_topic_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_topic_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_topic_stmtContext) TOPIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTOPIC, 0) + return s.GetToken(YQLParserTOPIC, 0) } func (s *Alter_topic_stmtContext) Topic_ref() ITopic_refContext { @@ -73045,19 +73045,19 @@ func (s *Alter_topic_stmtContext) Alter_topic_action(i int) IAlter_topic_actionC } func (s *Alter_topic_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Alter_topic_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Alter_topic_stmtContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_topic_stmtContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_topic_stmtContext) GetRuleContext() antlr.RuleContext { @@ -73070,13 +73070,13 @@ func (s *Alter_topic_stmtContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Alter_topic_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_stmt(s) } } func (s *Alter_topic_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_stmt(s) } } @@ -73084,15 +73084,15 @@ func (s *Alter_topic_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Alter_topic_stmt() (localctx IAlter_topic_stmtContext) { +func (p *YQLParser) Alter_topic_stmt() (localctx IAlter_topic_stmtContext) { localctx = NewAlter_topic_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 680, YQLv1Antlr4ParserRULE_alter_topic_stmt) + p.EnterRule(localctx, 680, YQLParserRULE_alter_topic_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4076) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73100,7 +73100,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_stmt() (localctx IAlter_topic_stmtContex } { p.SetState(4077) - p.Match(YQLv1Antlr4ParserTOPIC) + p.Match(YQLParserTOPIC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73113,7 +73113,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_stmt() (localctx IAlter_topic_stmtContex if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 { { p.SetState(4078) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73121,7 +73121,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_stmt() (localctx IAlter_topic_stmtContex } { p.SetState(4079) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73147,10 +73147,10 @@ func (p *YQLv1Antlr4Parser) Alter_topic_stmt() (localctx IAlter_topic_stmtContex _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4084) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73212,13 +73212,13 @@ type Alter_topic_actionContext struct { func NewEmptyAlter_topic_actionContext() *Alter_topic_actionContext { var p = new(Alter_topic_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_action + p.RuleIndex = YQLParserRULE_alter_topic_action return p } func InitEmptyAlter_topic_actionContext(p *Alter_topic_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_action + p.RuleIndex = YQLParserRULE_alter_topic_action } func (*Alter_topic_actionContext) IsAlter_topic_actionContext() {} @@ -73229,7 +73229,7 @@ func NewAlter_topic_actionContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_action + p.RuleIndex = YQLParserRULE_alter_topic_action return p } @@ -73326,13 +73326,13 @@ func (s *Alter_topic_actionContext) ToStringTree(ruleNames []string, recog antlr func (s *Alter_topic_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_action(s) } } func (s *Alter_topic_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_action(s) } } @@ -73340,9 +73340,9 @@ func (s *Alter_topic_actionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Alter_topic_action() (localctx IAlter_topic_actionContext) { +func (p *YQLParser) Alter_topic_action() (localctx IAlter_topic_actionContext) { localctx = NewAlter_topic_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 682, YQLv1Antlr4ParserRULE_alter_topic_action) + p.EnterRule(localctx, 682, YQLParserRULE_alter_topic_action) p.SetState(4096) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -73350,7 +73350,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_action() (localctx IAlter_topic_actionCo } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserADD: + case YQLParserADD: p.EnterOuterAlt(localctx, 1) { p.SetState(4091) @@ -73358,7 +73358,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_action() (localctx IAlter_topic_actionCo } - case YQLv1Antlr4ParserALTER: + case YQLParserALTER: p.EnterOuterAlt(localctx, 2) { p.SetState(4092) @@ -73366,7 +73366,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_action() (localctx IAlter_topic_actionCo } - case YQLv1Antlr4ParserDROP: + case YQLParserDROP: p.EnterOuterAlt(localctx, 3) { p.SetState(4093) @@ -73374,7 +73374,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_action() (localctx IAlter_topic_actionCo } - case YQLv1Antlr4ParserSET: + case YQLParserSET: p.EnterOuterAlt(localctx, 4) { p.SetState(4094) @@ -73382,7 +73382,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_action() (localctx IAlter_topic_actionCo } - case YQLv1Antlr4ParserRESET: + case YQLParserRESET: p.EnterOuterAlt(localctx, 5) { p.SetState(4095) @@ -73434,13 +73434,13 @@ type Alter_topic_add_consumerContext struct { func NewEmptyAlter_topic_add_consumerContext() *Alter_topic_add_consumerContext { var p = new(Alter_topic_add_consumerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_add_consumer + p.RuleIndex = YQLParserRULE_alter_topic_add_consumer return p } func InitEmptyAlter_topic_add_consumerContext(p *Alter_topic_add_consumerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_add_consumer + p.RuleIndex = YQLParserRULE_alter_topic_add_consumer } func (*Alter_topic_add_consumerContext) IsAlter_topic_add_consumerContext() {} @@ -73451,7 +73451,7 @@ func NewAlter_topic_add_consumerContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_add_consumer + p.RuleIndex = YQLParserRULE_alter_topic_add_consumer return p } @@ -73459,7 +73459,7 @@ func NewAlter_topic_add_consumerContext(parser antlr.Parser, parent antlr.Parser func (s *Alter_topic_add_consumerContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_topic_add_consumerContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Alter_topic_add_consumerContext) Topic_create_consumer_entry() ITopic_create_consumer_entryContext { @@ -73488,13 +73488,13 @@ func (s *Alter_topic_add_consumerContext) ToStringTree(ruleNames []string, recog func (s *Alter_topic_add_consumerContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_add_consumer(s) } } func (s *Alter_topic_add_consumerContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_add_consumer(s) } } @@ -73502,13 +73502,13 @@ func (s *Alter_topic_add_consumerContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Alter_topic_add_consumer() (localctx IAlter_topic_add_consumerContext) { +func (p *YQLParser) Alter_topic_add_consumer() (localctx IAlter_topic_add_consumerContext) { localctx = NewAlter_topic_add_consumerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 684, YQLv1Antlr4ParserRULE_alter_topic_add_consumer) + p.EnterRule(localctx, 684, YQLParserRULE_alter_topic_add_consumer) p.EnterOuterAlt(localctx, 1) { p.SetState(4098) - p.Match(YQLv1Antlr4ParserADD) + p.Match(YQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73559,13 +73559,13 @@ type Topic_create_consumer_entryContext struct { func NewEmptyTopic_create_consumer_entryContext() *Topic_create_consumer_entryContext { var p = new(Topic_create_consumer_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_create_consumer_entry + p.RuleIndex = YQLParserRULE_topic_create_consumer_entry return p } func InitEmptyTopic_create_consumer_entryContext(p *Topic_create_consumer_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_create_consumer_entry + p.RuleIndex = YQLParserRULE_topic_create_consumer_entry } func (*Topic_create_consumer_entryContext) IsTopic_create_consumer_entryContext() {} @@ -73576,7 +73576,7 @@ func NewTopic_create_consumer_entryContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_create_consumer_entry + p.RuleIndex = YQLParserRULE_topic_create_consumer_entry return p } @@ -73584,7 +73584,7 @@ func NewTopic_create_consumer_entryContext(parser antlr.Parser, parent antlr.Par func (s *Topic_create_consumer_entryContext) GetParser() antlr.Parser { return s.parser } func (s *Topic_create_consumer_entryContext) CONSUMER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONSUMER, 0) + return s.GetToken(YQLParserCONSUMER, 0) } func (s *Topic_create_consumer_entryContext) An_id() IAn_idContext { @@ -73629,13 +73629,13 @@ func (s *Topic_create_consumer_entryContext) ToStringTree(ruleNames []string, re func (s *Topic_create_consumer_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_create_consumer_entry(s) } } func (s *Topic_create_consumer_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_create_consumer_entry(s) } } @@ -73643,15 +73643,15 @@ func (s *Topic_create_consumer_entryContext) ExitRule(listener antlr.ParseTreeLi -func (p *YQLv1Antlr4Parser) Topic_create_consumer_entry() (localctx ITopic_create_consumer_entryContext) { +func (p *YQLParser) Topic_create_consumer_entry() (localctx ITopic_create_consumer_entryContext) { localctx = NewTopic_create_consumer_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 686, YQLv1Antlr4ParserRULE_topic_create_consumer_entry) + p.EnterRule(localctx, 686, YQLParserRULE_topic_create_consumer_entry) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4101) - p.Match(YQLv1Antlr4ParserCONSUMER) + p.Match(YQLParserCONSUMER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73669,7 +73669,7 @@ func (p *YQLv1Antlr4Parser) Topic_create_consumer_entry() (localctx ITopic_creat _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(4103) p.Topic_consumer_with_settings() @@ -73718,13 +73718,13 @@ type Alter_topic_alter_consumerContext struct { func NewEmptyAlter_topic_alter_consumerContext() *Alter_topic_alter_consumerContext { var p = new(Alter_topic_alter_consumerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_alter_consumer + p.RuleIndex = YQLParserRULE_alter_topic_alter_consumer return p } func InitEmptyAlter_topic_alter_consumerContext(p *Alter_topic_alter_consumerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_alter_consumer + p.RuleIndex = YQLParserRULE_alter_topic_alter_consumer } func (*Alter_topic_alter_consumerContext) IsAlter_topic_alter_consumerContext() {} @@ -73735,7 +73735,7 @@ func NewAlter_topic_alter_consumerContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_alter_consumer + p.RuleIndex = YQLParserRULE_alter_topic_alter_consumer return p } @@ -73743,11 +73743,11 @@ func NewAlter_topic_alter_consumerContext(parser antlr.Parser, parent antlr.Pars func (s *Alter_topic_alter_consumerContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_topic_alter_consumerContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_topic_alter_consumerContext) CONSUMER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONSUMER, 0) + return s.GetToken(YQLParserCONSUMER, 0) } func (s *Alter_topic_alter_consumerContext) Topic_consumer_ref() ITopic_consumer_refContext { @@ -73792,13 +73792,13 @@ func (s *Alter_topic_alter_consumerContext) ToStringTree(ruleNames []string, rec func (s *Alter_topic_alter_consumerContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_alter_consumer(s) } } func (s *Alter_topic_alter_consumerContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_alter_consumer(s) } } @@ -73806,13 +73806,13 @@ func (s *Alter_topic_alter_consumerContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Alter_topic_alter_consumer() (localctx IAlter_topic_alter_consumerContext) { +func (p *YQLParser) Alter_topic_alter_consumer() (localctx IAlter_topic_alter_consumerContext) { localctx = NewAlter_topic_alter_consumerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 688, YQLv1Antlr4ParserRULE_alter_topic_alter_consumer) + p.EnterRule(localctx, 688, YQLParserRULE_alter_topic_alter_consumer) p.EnterOuterAlt(localctx, 1) { p.SetState(4106) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73820,7 +73820,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_alter_consumer() (localctx IAlter_topic_ } { p.SetState(4107) - p.Match(YQLv1Antlr4ParserCONSUMER) + p.Match(YQLParserCONSUMER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73874,13 +73874,13 @@ type Alter_topic_alter_consumer_entryContext struct { func NewEmptyAlter_topic_alter_consumer_entryContext() *Alter_topic_alter_consumer_entryContext { var p = new(Alter_topic_alter_consumer_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_alter_consumer_entry + p.RuleIndex = YQLParserRULE_alter_topic_alter_consumer_entry return p } func InitEmptyAlter_topic_alter_consumer_entryContext(p *Alter_topic_alter_consumer_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_alter_consumer_entry + p.RuleIndex = YQLParserRULE_alter_topic_alter_consumer_entry } func (*Alter_topic_alter_consumer_entryContext) IsAlter_topic_alter_consumer_entryContext() {} @@ -73891,7 +73891,7 @@ func NewAlter_topic_alter_consumer_entryContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_alter_consumer_entry + p.RuleIndex = YQLParserRULE_alter_topic_alter_consumer_entry return p } @@ -73940,13 +73940,13 @@ func (s *Alter_topic_alter_consumer_entryContext) ToStringTree(ruleNames []strin func (s *Alter_topic_alter_consumer_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_alter_consumer_entry(s) } } func (s *Alter_topic_alter_consumer_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_alter_consumer_entry(s) } } @@ -73954,9 +73954,9 @@ func (s *Alter_topic_alter_consumer_entryContext) ExitRule(listener antlr.ParseT -func (p *YQLv1Antlr4Parser) Alter_topic_alter_consumer_entry() (localctx IAlter_topic_alter_consumer_entryContext) { +func (p *YQLParser) Alter_topic_alter_consumer_entry() (localctx IAlter_topic_alter_consumer_entryContext) { localctx = NewAlter_topic_alter_consumer_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 690, YQLv1Antlr4ParserRULE_alter_topic_alter_consumer_entry) + p.EnterRule(localctx, 690, YQLParserRULE_alter_topic_alter_consumer_entry) p.SetState(4113) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -73964,7 +73964,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_alter_consumer_entry() (localctx IAlter_ } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserSET: + case YQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(4111) @@ -73972,7 +73972,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_alter_consumer_entry() (localctx IAlter_ } - case YQLv1Antlr4ParserRESET: + case YQLParserRESET: p.EnterOuterAlt(localctx, 2) { p.SetState(4112) @@ -74025,13 +74025,13 @@ type Alter_topic_drop_consumerContext struct { func NewEmptyAlter_topic_drop_consumerContext() *Alter_topic_drop_consumerContext { var p = new(Alter_topic_drop_consumerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_drop_consumer + p.RuleIndex = YQLParserRULE_alter_topic_drop_consumer return p } func InitEmptyAlter_topic_drop_consumerContext(p *Alter_topic_drop_consumerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_drop_consumer + p.RuleIndex = YQLParserRULE_alter_topic_drop_consumer } func (*Alter_topic_drop_consumerContext) IsAlter_topic_drop_consumerContext() {} @@ -74042,7 +74042,7 @@ func NewAlter_topic_drop_consumerContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_drop_consumer + p.RuleIndex = YQLParserRULE_alter_topic_drop_consumer return p } @@ -74050,11 +74050,11 @@ func NewAlter_topic_drop_consumerContext(parser antlr.Parser, parent antlr.Parse func (s *Alter_topic_drop_consumerContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_topic_drop_consumerContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Alter_topic_drop_consumerContext) CONSUMER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONSUMER, 0) + return s.GetToken(YQLParserCONSUMER, 0) } func (s *Alter_topic_drop_consumerContext) Topic_consumer_ref() ITopic_consumer_refContext { @@ -74083,13 +74083,13 @@ func (s *Alter_topic_drop_consumerContext) ToStringTree(ruleNames []string, reco func (s *Alter_topic_drop_consumerContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_drop_consumer(s) } } func (s *Alter_topic_drop_consumerContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_drop_consumer(s) } } @@ -74097,13 +74097,13 @@ func (s *Alter_topic_drop_consumerContext) ExitRule(listener antlr.ParseTreeList -func (p *YQLv1Antlr4Parser) Alter_topic_drop_consumer() (localctx IAlter_topic_drop_consumerContext) { +func (p *YQLParser) Alter_topic_drop_consumer() (localctx IAlter_topic_drop_consumerContext) { localctx = NewAlter_topic_drop_consumerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 692, YQLv1Antlr4ParserRULE_alter_topic_drop_consumer) + p.EnterRule(localctx, 692, YQLParserRULE_alter_topic_drop_consumer) p.EnterOuterAlt(localctx, 1) { p.SetState(4115) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74111,7 +74111,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_drop_consumer() (localctx IAlter_topic_d } { p.SetState(4116) - p.Match(YQLv1Antlr4ParserCONSUMER) + p.Match(YQLParserCONSUMER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74163,13 +74163,13 @@ type Topic_alter_consumer_setContext struct { func NewEmptyTopic_alter_consumer_setContext() *Topic_alter_consumer_setContext { var p = new(Topic_alter_consumer_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_alter_consumer_set + p.RuleIndex = YQLParserRULE_topic_alter_consumer_set return p } func InitEmptyTopic_alter_consumer_setContext(p *Topic_alter_consumer_setContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_alter_consumer_set + p.RuleIndex = YQLParserRULE_topic_alter_consumer_set } func (*Topic_alter_consumer_setContext) IsTopic_alter_consumer_setContext() {} @@ -74180,7 +74180,7 @@ func NewTopic_alter_consumer_setContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_alter_consumer_set + p.RuleIndex = YQLParserRULE_topic_alter_consumer_set return p } @@ -74188,11 +74188,11 @@ func NewTopic_alter_consumer_setContext(parser antlr.Parser, parent antlr.Parser func (s *Topic_alter_consumer_setContext) GetParser() antlr.Parser { return s.parser } func (s *Topic_alter_consumer_setContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Topic_alter_consumer_setContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Topic_alter_consumer_setContext) Topic_consumer_settings() ITopic_consumer_settingsContext { @@ -74212,7 +74212,7 @@ func (s *Topic_alter_consumer_setContext) Topic_consumer_settings() ITopic_consu } func (s *Topic_alter_consumer_setContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Topic_alter_consumer_setContext) GetRuleContext() antlr.RuleContext { @@ -74225,13 +74225,13 @@ func (s *Topic_alter_consumer_setContext) ToStringTree(ruleNames []string, recog func (s *Topic_alter_consumer_setContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_alter_consumer_set(s) } } func (s *Topic_alter_consumer_setContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_alter_consumer_set(s) } } @@ -74239,13 +74239,13 @@ func (s *Topic_alter_consumer_setContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Topic_alter_consumer_set() (localctx ITopic_alter_consumer_setContext) { +func (p *YQLParser) Topic_alter_consumer_set() (localctx ITopic_alter_consumer_setContext) { localctx = NewTopic_alter_consumer_setContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 694, YQLv1Antlr4ParserRULE_topic_alter_consumer_set) + p.EnterRule(localctx, 694, YQLParserRULE_topic_alter_consumer_set) p.EnterOuterAlt(localctx, 1) { p.SetState(4119) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74253,7 +74253,7 @@ func (p *YQLv1Antlr4Parser) Topic_alter_consumer_set() (localctx ITopic_alter_co } { p.SetState(4120) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74265,7 +74265,7 @@ func (p *YQLv1Antlr4Parser) Topic_alter_consumer_set() (localctx ITopic_alter_co } { p.SetState(4122) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74316,13 +74316,13 @@ type Topic_alter_consumer_resetContext struct { func NewEmptyTopic_alter_consumer_resetContext() *Topic_alter_consumer_resetContext { var p = new(Topic_alter_consumer_resetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_alter_consumer_reset + p.RuleIndex = YQLParserRULE_topic_alter_consumer_reset return p } func InitEmptyTopic_alter_consumer_resetContext(p *Topic_alter_consumer_resetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_alter_consumer_reset + p.RuleIndex = YQLParserRULE_topic_alter_consumer_reset } func (*Topic_alter_consumer_resetContext) IsTopic_alter_consumer_resetContext() {} @@ -74333,7 +74333,7 @@ func NewTopic_alter_consumer_resetContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_alter_consumer_reset + p.RuleIndex = YQLParserRULE_topic_alter_consumer_reset return p } @@ -74341,11 +74341,11 @@ func NewTopic_alter_consumer_resetContext(parser antlr.Parser, parent antlr.Pars func (s *Topic_alter_consumer_resetContext) GetParser() antlr.Parser { return s.parser } func (s *Topic_alter_consumer_resetContext) RESET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESET, 0) + return s.GetToken(YQLParserRESET, 0) } func (s *Topic_alter_consumer_resetContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Topic_alter_consumer_resetContext) AllAn_id() []IAn_idContext { @@ -74390,15 +74390,15 @@ func (s *Topic_alter_consumer_resetContext) An_id(i int) IAn_idContext { } func (s *Topic_alter_consumer_resetContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Topic_alter_consumer_resetContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Topic_alter_consumer_resetContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Topic_alter_consumer_resetContext) GetRuleContext() antlr.RuleContext { @@ -74411,13 +74411,13 @@ func (s *Topic_alter_consumer_resetContext) ToStringTree(ruleNames []string, rec func (s *Topic_alter_consumer_resetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_alter_consumer_reset(s) } } func (s *Topic_alter_consumer_resetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_alter_consumer_reset(s) } } @@ -74425,15 +74425,15 @@ func (s *Topic_alter_consumer_resetContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Topic_alter_consumer_reset() (localctx ITopic_alter_consumer_resetContext) { +func (p *YQLParser) Topic_alter_consumer_reset() (localctx ITopic_alter_consumer_resetContext) { localctx = NewTopic_alter_consumer_resetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 696, YQLv1Antlr4ParserRULE_topic_alter_consumer_reset) + p.EnterRule(localctx, 696, YQLParserRULE_topic_alter_consumer_reset) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4124) - p.Match(YQLv1Antlr4ParserRESET) + p.Match(YQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74441,7 +74441,7 @@ func (p *YQLv1Antlr4Parser) Topic_alter_consumer_reset() (localctx ITopic_alter_ } { p.SetState(4125) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74459,10 +74459,10 @@ func (p *YQLv1Antlr4Parser) Topic_alter_consumer_reset() (localctx ITopic_alter_ _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4127) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74483,7 +74483,7 @@ func (p *YQLv1Antlr4Parser) Topic_alter_consumer_reset() (localctx ITopic_alter_ } { p.SetState(4134) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74531,13 +74531,13 @@ type Alter_topic_set_settingsContext struct { func NewEmptyAlter_topic_set_settingsContext() *Alter_topic_set_settingsContext { var p = new(Alter_topic_set_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_set_settings + p.RuleIndex = YQLParserRULE_alter_topic_set_settings return p } func InitEmptyAlter_topic_set_settingsContext(p *Alter_topic_set_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_set_settings + p.RuleIndex = YQLParserRULE_alter_topic_set_settings } func (*Alter_topic_set_settingsContext) IsAlter_topic_set_settingsContext() {} @@ -74548,7 +74548,7 @@ func NewAlter_topic_set_settingsContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_set_settings + p.RuleIndex = YQLParserRULE_alter_topic_set_settings return p } @@ -74556,11 +74556,11 @@ func NewAlter_topic_set_settingsContext(parser antlr.Parser, parent antlr.Parser func (s *Alter_topic_set_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_topic_set_settingsContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Alter_topic_set_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Alter_topic_set_settingsContext) Topic_settings() ITopic_settingsContext { @@ -74580,7 +74580,7 @@ func (s *Alter_topic_set_settingsContext) Topic_settings() ITopic_settingsContex } func (s *Alter_topic_set_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Alter_topic_set_settingsContext) GetRuleContext() antlr.RuleContext { @@ -74593,13 +74593,13 @@ func (s *Alter_topic_set_settingsContext) ToStringTree(ruleNames []string, recog func (s *Alter_topic_set_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_set_settings(s) } } func (s *Alter_topic_set_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_set_settings(s) } } @@ -74607,13 +74607,13 @@ func (s *Alter_topic_set_settingsContext) ExitRule(listener antlr.ParseTreeListe -func (p *YQLv1Antlr4Parser) Alter_topic_set_settings() (localctx IAlter_topic_set_settingsContext) { +func (p *YQLParser) Alter_topic_set_settings() (localctx IAlter_topic_set_settingsContext) { localctx = NewAlter_topic_set_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 698, YQLv1Antlr4ParserRULE_alter_topic_set_settings) + p.EnterRule(localctx, 698, YQLParserRULE_alter_topic_set_settings) p.EnterOuterAlt(localctx, 1) { p.SetState(4136) - p.Match(YQLv1Antlr4ParserSET) + p.Match(YQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74621,7 +74621,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_set_settings() (localctx IAlter_topic_se } { p.SetState(4137) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74633,7 +74633,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_set_settings() (localctx IAlter_topic_se } { p.SetState(4139) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74685,13 +74685,13 @@ type Alter_topic_reset_settingsContext struct { func NewEmptyAlter_topic_reset_settingsContext() *Alter_topic_reset_settingsContext { var p = new(Alter_topic_reset_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_reset_settings + p.RuleIndex = YQLParserRULE_alter_topic_reset_settings return p } func InitEmptyAlter_topic_reset_settingsContext(p *Alter_topic_reset_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_reset_settings + p.RuleIndex = YQLParserRULE_alter_topic_reset_settings } func (*Alter_topic_reset_settingsContext) IsAlter_topic_reset_settingsContext() {} @@ -74702,7 +74702,7 @@ func NewAlter_topic_reset_settingsContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_topic_reset_settings + p.RuleIndex = YQLParserRULE_alter_topic_reset_settings return p } @@ -74710,11 +74710,11 @@ func NewAlter_topic_reset_settingsContext(parser antlr.Parser, parent antlr.Pars func (s *Alter_topic_reset_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_topic_reset_settingsContext) RESET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESET, 0) + return s.GetToken(YQLParserRESET, 0) } func (s *Alter_topic_reset_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Alter_topic_reset_settingsContext) An_id() IAn_idContext { @@ -74734,15 +74734,15 @@ func (s *Alter_topic_reset_settingsContext) An_id() IAn_idContext { } func (s *Alter_topic_reset_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Alter_topic_reset_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Alter_topic_reset_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Alter_topic_reset_settingsContext) AllAn_id_pure() []IAn_id_pureContext { @@ -74796,13 +74796,13 @@ func (s *Alter_topic_reset_settingsContext) ToStringTree(ruleNames []string, rec func (s *Alter_topic_reset_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_topic_reset_settings(s) } } func (s *Alter_topic_reset_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_topic_reset_settings(s) } } @@ -74810,15 +74810,15 @@ func (s *Alter_topic_reset_settingsContext) ExitRule(listener antlr.ParseTreeLis -func (p *YQLv1Antlr4Parser) Alter_topic_reset_settings() (localctx IAlter_topic_reset_settingsContext) { +func (p *YQLParser) Alter_topic_reset_settings() (localctx IAlter_topic_reset_settingsContext) { localctx = NewAlter_topic_reset_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 700, YQLv1Antlr4ParserRULE_alter_topic_reset_settings) + p.EnterRule(localctx, 700, YQLParserRULE_alter_topic_reset_settings) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4141) - p.Match(YQLv1Antlr4ParserRESET) + p.Match(YQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74826,7 +74826,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_reset_settings() (localctx IAlter_topic_ } { p.SetState(4142) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74844,10 +74844,10 @@ func (p *YQLv1Antlr4Parser) Alter_topic_reset_settings() (localctx IAlter_topic_ _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4144) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74868,7 +74868,7 @@ func (p *YQLv1Antlr4Parser) Alter_topic_reset_settings() (localctx IAlter_topic_ } { p.SetState(4151) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74917,13 +74917,13 @@ type Drop_topic_stmtContext struct { func NewEmptyDrop_topic_stmtContext() *Drop_topic_stmtContext { var p = new(Drop_topic_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_topic_stmt + p.RuleIndex = YQLParserRULE_drop_topic_stmt return p } func InitEmptyDrop_topic_stmtContext(p *Drop_topic_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_topic_stmt + p.RuleIndex = YQLParserRULE_drop_topic_stmt } func (*Drop_topic_stmtContext) IsDrop_topic_stmtContext() {} @@ -74934,7 +74934,7 @@ func NewDrop_topic_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_drop_topic_stmt + p.RuleIndex = YQLParserRULE_drop_topic_stmt return p } @@ -74942,11 +74942,11 @@ func NewDrop_topic_stmtContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Drop_topic_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_topic_stmtContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Drop_topic_stmtContext) TOPIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTOPIC, 0) + return s.GetToken(YQLParserTOPIC, 0) } func (s *Drop_topic_stmtContext) Topic_ref() ITopic_refContext { @@ -74966,11 +74966,11 @@ func (s *Drop_topic_stmtContext) Topic_ref() ITopic_refContext { } func (s *Drop_topic_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Drop_topic_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Drop_topic_stmtContext) GetRuleContext() antlr.RuleContext { @@ -74983,13 +74983,13 @@ func (s *Drop_topic_stmtContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *Drop_topic_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterDrop_topic_stmt(s) } } func (s *Drop_topic_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitDrop_topic_stmt(s) } } @@ -74997,13 +74997,13 @@ func (s *Drop_topic_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Drop_topic_stmt() (localctx IDrop_topic_stmtContext) { +func (p *YQLParser) Drop_topic_stmt() (localctx IDrop_topic_stmtContext) { localctx = NewDrop_topic_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 702, YQLv1Antlr4ParserRULE_drop_topic_stmt) + p.EnterRule(localctx, 702, YQLParserRULE_drop_topic_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4153) - p.Match(YQLv1Antlr4ParserDROP) + p.Match(YQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75011,7 +75011,7 @@ func (p *YQLv1Antlr4Parser) Drop_topic_stmt() (localctx IDrop_topic_stmtContext) } { p.SetState(4154) - p.Match(YQLv1Antlr4ParserTOPIC) + p.Match(YQLParserTOPIC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75024,7 +75024,7 @@ func (p *YQLv1Antlr4Parser) Drop_topic_stmt() (localctx IDrop_topic_stmtContext) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 447, p.GetParserRuleContext()) == 1 { { p.SetState(4155) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75032,7 +75032,7 @@ func (p *YQLv1Antlr4Parser) Drop_topic_stmt() (localctx IDrop_topic_stmtContext) } { p.SetState(4156) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75088,13 +75088,13 @@ type Topic_settingsContext struct { func NewEmptyTopic_settingsContext() *Topic_settingsContext { var p = new(Topic_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_settings + p.RuleIndex = YQLParserRULE_topic_settings return p } func InitEmptyTopic_settingsContext(p *Topic_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_settings + p.RuleIndex = YQLParserRULE_topic_settings } func (*Topic_settingsContext) IsTopic_settingsContext() {} @@ -75105,7 +75105,7 @@ func NewTopic_settingsContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_settings + p.RuleIndex = YQLParserRULE_topic_settings return p } @@ -75154,11 +75154,11 @@ func (s *Topic_settingsContext) Topic_settings_entry(i int) ITopic_settings_entr } func (s *Topic_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Topic_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Topic_settingsContext) GetRuleContext() antlr.RuleContext { @@ -75171,13 +75171,13 @@ func (s *Topic_settingsContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Topic_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_settings(s) } } func (s *Topic_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_settings(s) } } @@ -75185,9 +75185,9 @@ func (s *Topic_settingsContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Topic_settings() (localctx ITopic_settingsContext) { +func (p *YQLParser) Topic_settings() (localctx ITopic_settingsContext) { localctx = NewTopic_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 704, YQLv1Antlr4ParserRULE_topic_settings) + p.EnterRule(localctx, 704, YQLParserRULE_topic_settings) var _la int p.EnterOuterAlt(localctx, 1) @@ -75203,10 +75203,10 @@ func (p *YQLv1Antlr4Parser) Topic_settings() (localctx ITopic_settingsContext) { _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4162) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75266,13 +75266,13 @@ type Topic_settings_entryContext struct { func NewEmptyTopic_settings_entryContext() *Topic_settings_entryContext { var p = new(Topic_settings_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_settings_entry + p.RuleIndex = YQLParserRULE_topic_settings_entry return p } func InitEmptyTopic_settings_entryContext(p *Topic_settings_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_settings_entry + p.RuleIndex = YQLParserRULE_topic_settings_entry } func (*Topic_settings_entryContext) IsTopic_settings_entryContext() {} @@ -75283,7 +75283,7 @@ func NewTopic_settings_entryContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_settings_entry + p.RuleIndex = YQLParserRULE_topic_settings_entry return p } @@ -75307,7 +75307,7 @@ func (s *Topic_settings_entryContext) An_id() IAn_idContext { } func (s *Topic_settings_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Topic_settings_entryContext) Topic_setting_value() ITopic_setting_valueContext { @@ -75336,13 +75336,13 @@ func (s *Topic_settings_entryContext) ToStringTree(ruleNames []string, recog ant func (s *Topic_settings_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_settings_entry(s) } } func (s *Topic_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_settings_entry(s) } } @@ -75350,9 +75350,9 @@ func (s *Topic_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Topic_settings_entry() (localctx ITopic_settings_entryContext) { +func (p *YQLParser) Topic_settings_entry() (localctx ITopic_settings_entryContext) { localctx = NewTopic_settings_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 706, YQLv1Antlr4ParserRULE_topic_settings_entry) + p.EnterRule(localctx, 706, YQLParserRULE_topic_settings_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(4169) @@ -75360,7 +75360,7 @@ func (p *YQLv1Antlr4Parser) Topic_settings_entry() (localctx ITopic_settings_ent } { p.SetState(4170) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75409,13 +75409,13 @@ type Topic_setting_valueContext struct { func NewEmptyTopic_setting_valueContext() *Topic_setting_valueContext { var p = new(Topic_setting_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_setting_value + p.RuleIndex = YQLParserRULE_topic_setting_value return p } func InitEmptyTopic_setting_valueContext(p *Topic_setting_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_setting_value + p.RuleIndex = YQLParserRULE_topic_setting_value } func (*Topic_setting_valueContext) IsTopic_setting_valueContext() {} @@ -75426,7 +75426,7 @@ func NewTopic_setting_valueContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_setting_value + p.RuleIndex = YQLParserRULE_topic_setting_value return p } @@ -75459,13 +75459,13 @@ func (s *Topic_setting_valueContext) ToStringTree(ruleNames []string, recog antl func (s *Topic_setting_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_setting_value(s) } } func (s *Topic_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_setting_value(s) } } @@ -75473,9 +75473,9 @@ func (s *Topic_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Topic_setting_value() (localctx ITopic_setting_valueContext) { +func (p *YQLParser) Topic_setting_value() (localctx ITopic_setting_valueContext) { localctx = NewTopic_setting_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 708, YQLv1Antlr4ParserRULE_topic_setting_value) + p.EnterRule(localctx, 708, YQLParserRULE_topic_setting_value) p.EnterOuterAlt(localctx, 1) { p.SetState(4173) @@ -75523,13 +75523,13 @@ type Topic_consumer_with_settingsContext struct { func NewEmptyTopic_consumer_with_settingsContext() *Topic_consumer_with_settingsContext { var p = new(Topic_consumer_with_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_with_settings + p.RuleIndex = YQLParserRULE_topic_consumer_with_settings return p } func InitEmptyTopic_consumer_with_settingsContext(p *Topic_consumer_with_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_with_settings + p.RuleIndex = YQLParserRULE_topic_consumer_with_settings } func (*Topic_consumer_with_settingsContext) IsTopic_consumer_with_settingsContext() {} @@ -75540,7 +75540,7 @@ func NewTopic_consumer_with_settingsContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_with_settings + p.RuleIndex = YQLParserRULE_topic_consumer_with_settings return p } @@ -75548,11 +75548,11 @@ func NewTopic_consumer_with_settingsContext(parser antlr.Parser, parent antlr.Pa func (s *Topic_consumer_with_settingsContext) GetParser() antlr.Parser { return s.parser } func (s *Topic_consumer_with_settingsContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Topic_consumer_with_settingsContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Topic_consumer_with_settingsContext) Topic_consumer_settings() ITopic_consumer_settingsContext { @@ -75572,7 +75572,7 @@ func (s *Topic_consumer_with_settingsContext) Topic_consumer_settings() ITopic_c } func (s *Topic_consumer_with_settingsContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Topic_consumer_with_settingsContext) GetRuleContext() antlr.RuleContext { @@ -75585,13 +75585,13 @@ func (s *Topic_consumer_with_settingsContext) ToStringTree(ruleNames []string, r func (s *Topic_consumer_with_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_consumer_with_settings(s) } } func (s *Topic_consumer_with_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_consumer_with_settings(s) } } @@ -75599,13 +75599,13 @@ func (s *Topic_consumer_with_settingsContext) ExitRule(listener antlr.ParseTreeL -func (p *YQLv1Antlr4Parser) Topic_consumer_with_settings() (localctx ITopic_consumer_with_settingsContext) { +func (p *YQLParser) Topic_consumer_with_settings() (localctx ITopic_consumer_with_settingsContext) { localctx = NewTopic_consumer_with_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 710, YQLv1Antlr4ParserRULE_topic_consumer_with_settings) + p.EnterRule(localctx, 710, YQLParserRULE_topic_consumer_with_settings) p.EnterOuterAlt(localctx, 1) { p.SetState(4175) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75613,7 +75613,7 @@ func (p *YQLv1Antlr4Parser) Topic_consumer_with_settings() (localctx ITopic_cons } { p.SetState(4176) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75625,7 +75625,7 @@ func (p *YQLv1Antlr4Parser) Topic_consumer_with_settings() (localctx ITopic_cons } { p.SetState(4178) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75673,13 +75673,13 @@ type Topic_consumer_settingsContext struct { func NewEmptyTopic_consumer_settingsContext() *Topic_consumer_settingsContext { var p = new(Topic_consumer_settingsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_settings + p.RuleIndex = YQLParserRULE_topic_consumer_settings return p } func InitEmptyTopic_consumer_settingsContext(p *Topic_consumer_settingsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_settings + p.RuleIndex = YQLParserRULE_topic_consumer_settings } func (*Topic_consumer_settingsContext) IsTopic_consumer_settingsContext() {} @@ -75690,7 +75690,7 @@ func NewTopic_consumer_settingsContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_settings + p.RuleIndex = YQLParserRULE_topic_consumer_settings return p } @@ -75739,11 +75739,11 @@ func (s *Topic_consumer_settingsContext) Topic_consumer_settings_entry(i int) IT } func (s *Topic_consumer_settingsContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Topic_consumer_settingsContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Topic_consumer_settingsContext) GetRuleContext() antlr.RuleContext { @@ -75756,13 +75756,13 @@ func (s *Topic_consumer_settingsContext) ToStringTree(ruleNames []string, recog func (s *Topic_consumer_settingsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_consumer_settings(s) } } func (s *Topic_consumer_settingsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_consumer_settings(s) } } @@ -75770,9 +75770,9 @@ func (s *Topic_consumer_settingsContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Topic_consumer_settings() (localctx ITopic_consumer_settingsContext) { +func (p *YQLParser) Topic_consumer_settings() (localctx ITopic_consumer_settingsContext) { localctx = NewTopic_consumer_settingsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 712, YQLv1Antlr4ParserRULE_topic_consumer_settings) + p.EnterRule(localctx, 712, YQLParserRULE_topic_consumer_settings) var _la int p.EnterOuterAlt(localctx, 1) @@ -75788,10 +75788,10 @@ func (p *YQLv1Antlr4Parser) Topic_consumer_settings() (localctx ITopic_consumer_ _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4181) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75851,13 +75851,13 @@ type Topic_consumer_settings_entryContext struct { func NewEmptyTopic_consumer_settings_entryContext() *Topic_consumer_settings_entryContext { var p = new(Topic_consumer_settings_entryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_settings_entry + p.RuleIndex = YQLParserRULE_topic_consumer_settings_entry return p } func InitEmptyTopic_consumer_settings_entryContext(p *Topic_consumer_settings_entryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_settings_entry + p.RuleIndex = YQLParserRULE_topic_consumer_settings_entry } func (*Topic_consumer_settings_entryContext) IsTopic_consumer_settings_entryContext() {} @@ -75868,7 +75868,7 @@ func NewTopic_consumer_settings_entryContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_settings_entry + p.RuleIndex = YQLParserRULE_topic_consumer_settings_entry return p } @@ -75892,7 +75892,7 @@ func (s *Topic_consumer_settings_entryContext) An_id() IAn_idContext { } func (s *Topic_consumer_settings_entryContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Topic_consumer_settings_entryContext) Topic_consumer_setting_value() ITopic_consumer_setting_valueContext { @@ -75921,13 +75921,13 @@ func (s *Topic_consumer_settings_entryContext) ToStringTree(ruleNames []string, func (s *Topic_consumer_settings_entryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_consumer_settings_entry(s) } } func (s *Topic_consumer_settings_entryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_consumer_settings_entry(s) } } @@ -75935,9 +75935,9 @@ func (s *Topic_consumer_settings_entryContext) ExitRule(listener antlr.ParseTree -func (p *YQLv1Antlr4Parser) Topic_consumer_settings_entry() (localctx ITopic_consumer_settings_entryContext) { +func (p *YQLParser) Topic_consumer_settings_entry() (localctx ITopic_consumer_settings_entryContext) { localctx = NewTopic_consumer_settings_entryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 714, YQLv1Antlr4ParserRULE_topic_consumer_settings_entry) + p.EnterRule(localctx, 714, YQLParserRULE_topic_consumer_settings_entry) p.EnterOuterAlt(localctx, 1) { p.SetState(4188) @@ -75945,7 +75945,7 @@ func (p *YQLv1Antlr4Parser) Topic_consumer_settings_entry() (localctx ITopic_con } { p.SetState(4189) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75994,13 +75994,13 @@ type Topic_consumer_setting_valueContext struct { func NewEmptyTopic_consumer_setting_valueContext() *Topic_consumer_setting_valueContext { var p = new(Topic_consumer_setting_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_setting_value + p.RuleIndex = YQLParserRULE_topic_consumer_setting_value return p } func InitEmptyTopic_consumer_setting_valueContext(p *Topic_consumer_setting_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_setting_value + p.RuleIndex = YQLParserRULE_topic_consumer_setting_value } func (*Topic_consumer_setting_valueContext) IsTopic_consumer_setting_valueContext() {} @@ -76011,7 +76011,7 @@ func NewTopic_consumer_setting_valueContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_setting_value + p.RuleIndex = YQLParserRULE_topic_consumer_setting_value return p } @@ -76044,13 +76044,13 @@ func (s *Topic_consumer_setting_valueContext) ToStringTree(ruleNames []string, r func (s *Topic_consumer_setting_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_consumer_setting_value(s) } } func (s *Topic_consumer_setting_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_consumer_setting_value(s) } } @@ -76058,9 +76058,9 @@ func (s *Topic_consumer_setting_valueContext) ExitRule(listener antlr.ParseTreeL -func (p *YQLv1Antlr4Parser) Topic_consumer_setting_value() (localctx ITopic_consumer_setting_valueContext) { +func (p *YQLParser) Topic_consumer_setting_value() (localctx ITopic_consumer_setting_valueContext) { localctx = NewTopic_consumer_setting_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 716, YQLv1Antlr4ParserRULE_topic_consumer_setting_value) + p.EnterRule(localctx, 716, YQLParserRULE_topic_consumer_setting_value) p.EnterOuterAlt(localctx, 1) { p.SetState(4192) @@ -76107,13 +76107,13 @@ type Topic_refContext struct { func NewEmptyTopic_refContext() *Topic_refContext { var p = new(Topic_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_ref + p.RuleIndex = YQLParserRULE_topic_ref return p } func InitEmptyTopic_refContext(p *Topic_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_ref + p.RuleIndex = YQLParserRULE_topic_ref } func (*Topic_refContext) IsTopic_refContext() {} @@ -76124,7 +76124,7 @@ func NewTopic_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_ref + p.RuleIndex = YQLParserRULE_topic_ref return p } @@ -76164,7 +76164,7 @@ func (s *Topic_refContext) Cluster_expr() ICluster_exprContext { } func (s *Topic_refContext) DOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, 0) + return s.GetToken(YQLParserDOT, 0) } func (s *Topic_refContext) GetRuleContext() antlr.RuleContext { @@ -76177,13 +76177,13 @@ func (s *Topic_refContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Topic_refContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_ref(s) } } func (s *Topic_refContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_ref(s) } } @@ -76191,9 +76191,9 @@ func (s *Topic_refContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Topic_ref() (localctx ITopic_refContext) { +func (p *YQLParser) Topic_ref() (localctx ITopic_refContext) { localctx = NewTopic_refContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 718, YQLv1Antlr4ParserRULE_topic_ref) + p.EnterRule(localctx, 718, YQLParserRULE_topic_ref) p.EnterOuterAlt(localctx, 1) p.SetState(4197) p.GetErrorHandler().Sync(p) @@ -76206,7 +76206,7 @@ func (p *YQLv1Antlr4Parser) Topic_ref() (localctx ITopic_refContext) { } { p.SetState(4195) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76259,13 +76259,13 @@ type Topic_consumer_refContext struct { func NewEmptyTopic_consumer_refContext() *Topic_consumer_refContext { var p = new(Topic_consumer_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_ref + p.RuleIndex = YQLParserRULE_topic_consumer_ref return p } func InitEmptyTopic_consumer_refContext(p *Topic_consumer_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_ref + p.RuleIndex = YQLParserRULE_topic_consumer_ref } func (*Topic_consumer_refContext) IsTopic_consumer_refContext() {} @@ -76276,7 +76276,7 @@ func NewTopic_consumer_refContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_topic_consumer_ref + p.RuleIndex = YQLParserRULE_topic_consumer_ref return p } @@ -76309,13 +76309,13 @@ func (s *Topic_consumer_refContext) ToStringTree(ruleNames []string, recog antlr func (s *Topic_consumer_refContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterTopic_consumer_ref(s) } } func (s *Topic_consumer_refContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitTopic_consumer_ref(s) } } @@ -76323,9 +76323,9 @@ func (s *Topic_consumer_refContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Topic_consumer_ref() (localctx ITopic_consumer_refContext) { +func (p *YQLParser) Topic_consumer_ref() (localctx ITopic_consumer_refContext) { localctx = NewTopic_consumer_refContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 720, YQLv1Antlr4ParserRULE_topic_consumer_ref) + p.EnterRule(localctx, 720, YQLParserRULE_topic_consumer_ref) p.EnterOuterAlt(localctx, 1) { p.SetState(4201) @@ -76372,13 +76372,13 @@ type Null_treatmentContext struct { func NewEmptyNull_treatmentContext() *Null_treatmentContext { var p = new(Null_treatmentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_null_treatment + p.RuleIndex = YQLParserRULE_null_treatment return p } func InitEmptyNull_treatmentContext(p *Null_treatmentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_null_treatment + p.RuleIndex = YQLParserRULE_null_treatment } func (*Null_treatmentContext) IsNull_treatmentContext() {} @@ -76389,7 +76389,7 @@ func NewNull_treatmentContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_null_treatment + p.RuleIndex = YQLParserRULE_null_treatment return p } @@ -76397,15 +76397,15 @@ func NewNull_treatmentContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Null_treatmentContext) GetParser() antlr.Parser { return s.parser } func (s *Null_treatmentContext) RESPECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESPECT, 0) + return s.GetToken(YQLParserRESPECT, 0) } func (s *Null_treatmentContext) NULLS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULLS, 0) + return s.GetToken(YQLParserNULLS, 0) } func (s *Null_treatmentContext) IGNORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIGNORE, 0) + return s.GetToken(YQLParserIGNORE, 0) } func (s *Null_treatmentContext) GetRuleContext() antlr.RuleContext { @@ -76418,13 +76418,13 @@ func (s *Null_treatmentContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Null_treatmentContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNull_treatment(s) } } func (s *Null_treatmentContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNull_treatment(s) } } @@ -76432,9 +76432,9 @@ func (s *Null_treatmentContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Null_treatment() (localctx INull_treatmentContext) { +func (p *YQLParser) Null_treatment() (localctx INull_treatmentContext) { localctx = NewNull_treatmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 722, YQLv1Antlr4ParserRULE_null_treatment) + p.EnterRule(localctx, 722, YQLParserRULE_null_treatment) p.SetState(4207) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -76442,11 +76442,11 @@ func (p *YQLv1Antlr4Parser) Null_treatment() (localctx INull_treatmentContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserRESPECT: + case YQLParserRESPECT: p.EnterOuterAlt(localctx, 1) { p.SetState(4203) - p.Match(YQLv1Antlr4ParserRESPECT) + p.Match(YQLParserRESPECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76454,7 +76454,7 @@ func (p *YQLv1Antlr4Parser) Null_treatment() (localctx INull_treatmentContext) { } { p.SetState(4204) - p.Match(YQLv1Antlr4ParserNULLS) + p.Match(YQLParserNULLS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76462,11 +76462,11 @@ func (p *YQLv1Antlr4Parser) Null_treatment() (localctx INull_treatmentContext) { } - case YQLv1Antlr4ParserIGNORE: + case YQLParserIGNORE: p.EnterOuterAlt(localctx, 2) { p.SetState(4205) - p.Match(YQLv1Antlr4ParserIGNORE) + p.Match(YQLParserIGNORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76474,7 +76474,7 @@ func (p *YQLv1Antlr4Parser) Null_treatment() (localctx INull_treatmentContext) { } { p.SetState(4206) - p.Match(YQLv1Antlr4ParserNULLS) + p.Match(YQLParserNULLS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76529,13 +76529,13 @@ type Filter_clauseContext struct { func NewEmptyFilter_clauseContext() *Filter_clauseContext { var p = new(Filter_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_filter_clause + p.RuleIndex = YQLParserRULE_filter_clause return p } func InitEmptyFilter_clauseContext(p *Filter_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_filter_clause + p.RuleIndex = YQLParserRULE_filter_clause } func (*Filter_clauseContext) IsFilter_clauseContext() {} @@ -76546,7 +76546,7 @@ func NewFilter_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_filter_clause + p.RuleIndex = YQLParserRULE_filter_clause return p } @@ -76554,15 +76554,15 @@ func NewFilter_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Filter_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Filter_clauseContext) FILTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFILTER, 0) + return s.GetToken(YQLParserFILTER, 0) } func (s *Filter_clauseContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Filter_clauseContext) WHERE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHERE, 0) + return s.GetToken(YQLParserWHERE, 0) } func (s *Filter_clauseContext) Expr() IExprContext { @@ -76582,7 +76582,7 @@ func (s *Filter_clauseContext) Expr() IExprContext { } func (s *Filter_clauseContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Filter_clauseContext) GetRuleContext() antlr.RuleContext { @@ -76595,13 +76595,13 @@ func (s *Filter_clauseContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterFilter_clause(s) } } func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitFilter_clause(s) } } @@ -76609,13 +76609,13 @@ func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Filter_clause() (localctx IFilter_clauseContext) { +func (p *YQLParser) Filter_clause() (localctx IFilter_clauseContext) { localctx = NewFilter_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 724, YQLv1Antlr4ParserRULE_filter_clause) + p.EnterRule(localctx, 724, YQLParserRULE_filter_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(4209) - p.Match(YQLv1Antlr4ParserFILTER) + p.Match(YQLParserFILTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76623,7 +76623,7 @@ func (p *YQLv1Antlr4Parser) Filter_clause() (localctx IFilter_clauseContext) { } { p.SetState(4210) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76631,7 +76631,7 @@ func (p *YQLv1Antlr4Parser) Filter_clause() (localctx IFilter_clauseContext) { } { p.SetState(4211) - p.Match(YQLv1Antlr4ParserWHERE) + p.Match(YQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76643,7 +76643,7 @@ func (p *YQLv1Antlr4Parser) Filter_clause() (localctx IFilter_clauseContext) { } { p.SetState(4213) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76689,13 +76689,13 @@ type Window_name_or_specificationContext struct { func NewEmptyWindow_name_or_specificationContext() *Window_name_or_specificationContext { var p = new(Window_name_or_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_name_or_specification + p.RuleIndex = YQLParserRULE_window_name_or_specification return p } func InitEmptyWindow_name_or_specificationContext(p *Window_name_or_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_name_or_specification + p.RuleIndex = YQLParserRULE_window_name_or_specification } func (*Window_name_or_specificationContext) IsWindow_name_or_specificationContext() {} @@ -76706,7 +76706,7 @@ func NewWindow_name_or_specificationContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_name_or_specification + p.RuleIndex = YQLParserRULE_window_name_or_specification return p } @@ -76755,13 +76755,13 @@ func (s *Window_name_or_specificationContext) ToStringTree(ruleNames []string, r func (s *Window_name_or_specificationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_name_or_specification(s) } } func (s *Window_name_or_specificationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_name_or_specification(s) } } @@ -76769,9 +76769,9 @@ func (s *Window_name_or_specificationContext) ExitRule(listener antlr.ParseTreeL -func (p *YQLv1Antlr4Parser) Window_name_or_specification() (localctx IWindow_name_or_specificationContext) { +func (p *YQLParser) Window_name_or_specification() (localctx IWindow_name_or_specificationContext) { localctx = NewWindow_name_or_specificationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 726, YQLv1Antlr4ParserRULE_window_name_or_specification) + p.EnterRule(localctx, 726, YQLParserRULE_window_name_or_specification) p.SetState(4217) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -76779,7 +76779,7 @@ func (p *YQLv1Antlr4Parser) Window_name_or_specification() (localctx IWindow_nam } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4215) @@ -76787,7 +76787,7 @@ func (p *YQLv1Antlr4Parser) Window_name_or_specification() (localctx IWindow_nam } - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(4216) @@ -76838,13 +76838,13 @@ type Window_nameContext struct { func NewEmptyWindow_nameContext() *Window_nameContext { var p = new(Window_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_name + p.RuleIndex = YQLParserRULE_window_name return p } func InitEmptyWindow_nameContext(p *Window_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_name + p.RuleIndex = YQLParserRULE_window_name } func (*Window_nameContext) IsWindow_nameContext() {} @@ -76855,7 +76855,7 @@ func NewWindow_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_name + p.RuleIndex = YQLParserRULE_window_name return p } @@ -76888,13 +76888,13 @@ func (s *Window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Window_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_name(s) } } func (s *Window_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_name(s) } } @@ -76902,9 +76902,9 @@ func (s *Window_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Window_name() (localctx IWindow_nameContext) { +func (p *YQLParser) Window_name() (localctx IWindow_nameContext) { localctx = NewWindow_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 728, YQLv1Antlr4ParserRULE_window_name) + p.EnterRule(localctx, 728, YQLParserRULE_window_name) p.EnterOuterAlt(localctx, 1) { p.SetState(4219) @@ -76950,13 +76950,13 @@ type Window_clauseContext struct { func NewEmptyWindow_clauseContext() *Window_clauseContext { var p = new(Window_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_clause + p.RuleIndex = YQLParserRULE_window_clause return p } func InitEmptyWindow_clauseContext(p *Window_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_clause + p.RuleIndex = YQLParserRULE_window_clause } func (*Window_clauseContext) IsWindow_clauseContext() {} @@ -76967,7 +76967,7 @@ func NewWindow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_clause + p.RuleIndex = YQLParserRULE_window_clause return p } @@ -76975,7 +76975,7 @@ func NewWindow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Window_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Window_clauseContext) WINDOW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWINDOW, 0) + return s.GetToken(YQLParserWINDOW, 0) } func (s *Window_clauseContext) Window_definition_list() IWindow_definition_listContext { @@ -77004,13 +77004,13 @@ func (s *Window_clauseContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Window_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_clause(s) } } func (s *Window_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_clause(s) } } @@ -77018,13 +77018,13 @@ func (s *Window_clauseContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Window_clause() (localctx IWindow_clauseContext) { +func (p *YQLParser) Window_clause() (localctx IWindow_clauseContext) { localctx = NewWindow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 730, YQLv1Antlr4ParserRULE_window_clause) + p.EnterRule(localctx, 730, YQLParserRULE_window_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(4221) - p.Match(YQLv1Antlr4ParserWINDOW) + p.Match(YQLParserWINDOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77076,13 +77076,13 @@ type Window_definition_listContext struct { func NewEmptyWindow_definition_listContext() *Window_definition_listContext { var p = new(Window_definition_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_definition_list + p.RuleIndex = YQLParserRULE_window_definition_list return p } func InitEmptyWindow_definition_listContext(p *Window_definition_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_definition_list + p.RuleIndex = YQLParserRULE_window_definition_list } func (*Window_definition_listContext) IsWindow_definition_listContext() {} @@ -77093,7 +77093,7 @@ func NewWindow_definition_listContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_definition_list + p.RuleIndex = YQLParserRULE_window_definition_list return p } @@ -77142,11 +77142,11 @@ func (s *Window_definition_listContext) Window_definition(i int) IWindow_definit } func (s *Window_definition_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Window_definition_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Window_definition_listContext) GetRuleContext() antlr.RuleContext { @@ -77159,13 +77159,13 @@ func (s *Window_definition_listContext) ToStringTree(ruleNames []string, recog a func (s *Window_definition_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_definition_list(s) } } func (s *Window_definition_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_definition_list(s) } } @@ -77173,9 +77173,9 @@ func (s *Window_definition_listContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Window_definition_list() (localctx IWindow_definition_listContext) { +func (p *YQLParser) Window_definition_list() (localctx IWindow_definition_listContext) { localctx = NewWindow_definition_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 732, YQLv1Antlr4ParserRULE_window_definition_list) + p.EnterRule(localctx, 732, YQLParserRULE_window_definition_list) var _la int p.EnterOuterAlt(localctx, 1) @@ -77191,10 +77191,10 @@ func (p *YQLv1Antlr4Parser) Window_definition_list() (localctx IWindow_definitio _la = p.GetTokenStream().LA(1) - for _la == YQLv1Antlr4ParserCOMMA { + for _la == YQLParserCOMMA { { p.SetState(4225) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77254,13 +77254,13 @@ type Window_definitionContext struct { func NewEmptyWindow_definitionContext() *Window_definitionContext { var p = new(Window_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_definition + p.RuleIndex = YQLParserRULE_window_definition return p } func InitEmptyWindow_definitionContext(p *Window_definitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_definition + p.RuleIndex = YQLParserRULE_window_definition } func (*Window_definitionContext) IsWindow_definitionContext() {} @@ -77271,7 +77271,7 @@ func NewWindow_definitionContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_definition + p.RuleIndex = YQLParserRULE_window_definition return p } @@ -77295,7 +77295,7 @@ func (s *Window_definitionContext) New_window_name() INew_window_nameContext { } func (s *Window_definitionContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Window_definitionContext) Window_specification() IWindow_specificationContext { @@ -77324,13 +77324,13 @@ func (s *Window_definitionContext) ToStringTree(ruleNames []string, recog antlr. func (s *Window_definitionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_definition(s) } } func (s *Window_definitionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_definition(s) } } @@ -77338,9 +77338,9 @@ func (s *Window_definitionContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Window_definition() (localctx IWindow_definitionContext) { +func (p *YQLParser) Window_definition() (localctx IWindow_definitionContext) { localctx = NewWindow_definitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 734, YQLv1Antlr4ParserRULE_window_definition) + p.EnterRule(localctx, 734, YQLParserRULE_window_definition) p.EnterOuterAlt(localctx, 1) { p.SetState(4232) @@ -77348,7 +77348,7 @@ func (p *YQLv1Antlr4Parser) Window_definition() (localctx IWindow_definitionCont } { p.SetState(4233) - p.Match(YQLv1Antlr4ParserAS) + p.Match(YQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77397,13 +77397,13 @@ type New_window_nameContext struct { func NewEmptyNew_window_nameContext() *New_window_nameContext { var p = new(New_window_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_new_window_name + p.RuleIndex = YQLParserRULE_new_window_name return p } func InitEmptyNew_window_nameContext(p *New_window_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_new_window_name + p.RuleIndex = YQLParserRULE_new_window_name } func (*New_window_nameContext) IsNew_window_nameContext() {} @@ -77414,7 +77414,7 @@ func NewNew_window_nameContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_new_window_name + p.RuleIndex = YQLParserRULE_new_window_name return p } @@ -77447,13 +77447,13 @@ func (s *New_window_nameContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *New_window_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNew_window_name(s) } } func (s *New_window_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNew_window_name(s) } } @@ -77461,9 +77461,9 @@ func (s *New_window_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) New_window_name() (localctx INew_window_nameContext) { +func (p *YQLParser) New_window_name() (localctx INew_window_nameContext) { localctx = NewNew_window_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 736, YQLv1Antlr4ParserRULE_new_window_name) + p.EnterRule(localctx, 736, YQLParserRULE_new_window_name) p.EnterOuterAlt(localctx, 1) { p.SetState(4236) @@ -77510,13 +77510,13 @@ type Window_specificationContext struct { func NewEmptyWindow_specificationContext() *Window_specificationContext { var p = new(Window_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_specification + p.RuleIndex = YQLParserRULE_window_specification return p } func InitEmptyWindow_specificationContext(p *Window_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_specification + p.RuleIndex = YQLParserRULE_window_specification } func (*Window_specificationContext) IsWindow_specificationContext() {} @@ -77527,7 +77527,7 @@ func NewWindow_specificationContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_specification + p.RuleIndex = YQLParserRULE_window_specification return p } @@ -77535,7 +77535,7 @@ func NewWindow_specificationContext(parser antlr.Parser, parent antlr.ParserRule func (s *Window_specificationContext) GetParser() antlr.Parser { return s.parser } func (s *Window_specificationContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Window_specificationContext) Window_specification_details() IWindow_specification_detailsContext { @@ -77555,7 +77555,7 @@ func (s *Window_specificationContext) Window_specification_details() IWindow_spe } func (s *Window_specificationContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Window_specificationContext) GetRuleContext() antlr.RuleContext { @@ -77568,13 +77568,13 @@ func (s *Window_specificationContext) ToStringTree(ruleNames []string, recog ant func (s *Window_specificationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_specification(s) } } func (s *Window_specificationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_specification(s) } } @@ -77582,13 +77582,13 @@ func (s *Window_specificationContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Window_specification() (localctx IWindow_specificationContext) { +func (p *YQLParser) Window_specification() (localctx IWindow_specificationContext) { localctx = NewWindow_specificationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 738, YQLv1Antlr4ParserRULE_window_specification) + p.EnterRule(localctx, 738, YQLParserRULE_window_specification) p.EnterOuterAlt(localctx, 1) { p.SetState(4238) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77600,7 +77600,7 @@ func (p *YQLv1Antlr4Parser) Window_specification() (localctx IWindow_specificati } { p.SetState(4240) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77648,13 +77648,13 @@ type Window_specification_detailsContext struct { func NewEmptyWindow_specification_detailsContext() *Window_specification_detailsContext { var p = new(Window_specification_detailsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_specification_details + p.RuleIndex = YQLParserRULE_window_specification_details return p } func InitEmptyWindow_specification_detailsContext(p *Window_specification_detailsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_specification_details + p.RuleIndex = YQLParserRULE_window_specification_details } func (*Window_specification_detailsContext) IsWindow_specification_detailsContext() {} @@ -77665,7 +77665,7 @@ func NewWindow_specification_detailsContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_specification_details + p.RuleIndex = YQLParserRULE_window_specification_details return p } @@ -77746,13 +77746,13 @@ func (s *Window_specification_detailsContext) ToStringTree(ruleNames []string, r func (s *Window_specification_detailsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_specification_details(s) } } func (s *Window_specification_detailsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_specification_details(s) } } @@ -77760,9 +77760,9 @@ func (s *Window_specification_detailsContext) ExitRule(listener antlr.ParseTreeL -func (p *YQLv1Antlr4Parser) Window_specification_details() (localctx IWindow_specification_detailsContext) { +func (p *YQLParser) Window_specification_details() (localctx IWindow_specification_detailsContext) { localctx = NewWindow_specification_detailsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 740, YQLv1Antlr4ParserRULE_window_specification_details) + p.EnterRule(localctx, 740, YQLParserRULE_window_specification_details) var _la int p.EnterOuterAlt(localctx, 1) @@ -77787,7 +77787,7 @@ func (p *YQLv1Antlr4Parser) Window_specification_details() (localctx IWindow_spe _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserPARTITION { + if _la == YQLParserPARTITION { { p.SetState(4245) p.Window_partition_clause() @@ -77802,7 +77802,7 @@ func (p *YQLv1Antlr4Parser) Window_specification_details() (localctx IWindow_spe _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserORDER { + if _la == YQLParserORDER { { p.SetState(4248) p.Window_order_clause() @@ -77817,7 +77817,7 @@ func (p *YQLv1Antlr4Parser) Window_specification_details() (localctx IWindow_spe _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserGROUPS || _la == YQLv1Antlr4ParserRANGE || _la == YQLv1Antlr4ParserROWS { + if _la == YQLParserGROUPS || _la == YQLParserRANGE || _la == YQLParserROWS { { p.SetState(4251) p.Window_frame_clause() @@ -77863,13 +77863,13 @@ type Existing_window_nameContext struct { func NewEmptyExisting_window_nameContext() *Existing_window_nameContext { var p = new(Existing_window_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_existing_window_name + p.RuleIndex = YQLParserRULE_existing_window_name return p } func InitEmptyExisting_window_nameContext(p *Existing_window_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_existing_window_name + p.RuleIndex = YQLParserRULE_existing_window_name } func (*Existing_window_nameContext) IsExisting_window_nameContext() {} @@ -77880,7 +77880,7 @@ func NewExisting_window_nameContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_existing_window_name + p.RuleIndex = YQLParserRULE_existing_window_name return p } @@ -77913,13 +77913,13 @@ func (s *Existing_window_nameContext) ToStringTree(ruleNames []string, recog ant func (s *Existing_window_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterExisting_window_name(s) } } func (s *Existing_window_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitExisting_window_name(s) } } @@ -77927,9 +77927,9 @@ func (s *Existing_window_nameContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Existing_window_name() (localctx IExisting_window_nameContext) { +func (p *YQLParser) Existing_window_name() (localctx IExisting_window_nameContext) { localctx = NewExisting_window_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 742, YQLv1Antlr4ParserRULE_existing_window_name) + p.EnterRule(localctx, 742, YQLParserRULE_existing_window_name) p.EnterOuterAlt(localctx, 1) { p.SetState(4254) @@ -77977,13 +77977,13 @@ type Window_partition_clauseContext struct { func NewEmptyWindow_partition_clauseContext() *Window_partition_clauseContext { var p = new(Window_partition_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_partition_clause + p.RuleIndex = YQLParserRULE_window_partition_clause return p } func InitEmptyWindow_partition_clauseContext(p *Window_partition_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_partition_clause + p.RuleIndex = YQLParserRULE_window_partition_clause } func (*Window_partition_clauseContext) IsWindow_partition_clauseContext() {} @@ -77994,7 +77994,7 @@ func NewWindow_partition_clauseContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_partition_clause + p.RuleIndex = YQLParserRULE_window_partition_clause return p } @@ -78002,11 +78002,11 @@ func NewWindow_partition_clauseContext(parser antlr.Parser, parent antlr.ParserR func (s *Window_partition_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Window_partition_clauseContext) PARTITION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARTITION, 0) + return s.GetToken(YQLParserPARTITION, 0) } func (s *Window_partition_clauseContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Window_partition_clauseContext) Named_expr_list() INamed_expr_listContext { @@ -78026,7 +78026,7 @@ func (s *Window_partition_clauseContext) Named_expr_list() INamed_expr_listConte } func (s *Window_partition_clauseContext) COMPACT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMPACT, 0) + return s.GetToken(YQLParserCOMPACT, 0) } func (s *Window_partition_clauseContext) GetRuleContext() antlr.RuleContext { @@ -78039,13 +78039,13 @@ func (s *Window_partition_clauseContext) ToStringTree(ruleNames []string, recog func (s *Window_partition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_partition_clause(s) } } func (s *Window_partition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_partition_clause(s) } } @@ -78053,15 +78053,15 @@ func (s *Window_partition_clauseContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Window_partition_clause() (localctx IWindow_partition_clauseContext) { +func (p *YQLParser) Window_partition_clause() (localctx IWindow_partition_clauseContext) { localctx = NewWindow_partition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 744, YQLv1Antlr4ParserRULE_window_partition_clause) + p.EnterRule(localctx, 744, YQLParserRULE_window_partition_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4256) - p.Match(YQLv1Antlr4ParserPARTITION) + p.Match(YQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78075,10 +78075,10 @@ func (p *YQLv1Antlr4Parser) Window_partition_clause() (localctx IWindow_partitio _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMPACT { + if _la == YQLParserCOMPACT { { p.SetState(4257) - p.Match(YQLv1Antlr4ParserCOMPACT) + p.Match(YQLParserCOMPACT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78088,7 +78088,7 @@ func (p *YQLv1Antlr4Parser) Window_partition_clause() (localctx IWindow_partitio } { p.SetState(4260) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78137,13 +78137,13 @@ type Window_order_clauseContext struct { func NewEmptyWindow_order_clauseContext() *Window_order_clauseContext { var p = new(Window_order_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_order_clause + p.RuleIndex = YQLParserRULE_window_order_clause return p } func InitEmptyWindow_order_clauseContext(p *Window_order_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_order_clause + p.RuleIndex = YQLParserRULE_window_order_clause } func (*Window_order_clauseContext) IsWindow_order_clauseContext() {} @@ -78154,7 +78154,7 @@ func NewWindow_order_clauseContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_order_clause + p.RuleIndex = YQLParserRULE_window_order_clause return p } @@ -78187,13 +78187,13 @@ func (s *Window_order_clauseContext) ToStringTree(ruleNames []string, recog antl func (s *Window_order_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_order_clause(s) } } func (s *Window_order_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_order_clause(s) } } @@ -78201,9 +78201,9 @@ func (s *Window_order_clauseContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Window_order_clause() (localctx IWindow_order_clauseContext) { +func (p *YQLParser) Window_order_clause() (localctx IWindow_order_clauseContext) { localctx = NewWindow_order_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 746, YQLv1Antlr4ParserRULE_window_order_clause) + p.EnterRule(localctx, 746, YQLParserRULE_window_order_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(4263) @@ -78250,13 +78250,13 @@ type Window_frame_clauseContext struct { func NewEmptyWindow_frame_clauseContext() *Window_frame_clauseContext { var p = new(Window_frame_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_clause + p.RuleIndex = YQLParserRULE_window_frame_clause return p } func InitEmptyWindow_frame_clauseContext(p *Window_frame_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_clause + p.RuleIndex = YQLParserRULE_window_frame_clause } func (*Window_frame_clauseContext) IsWindow_frame_clauseContext() {} @@ -78267,7 +78267,7 @@ func NewWindow_frame_clauseContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_clause + p.RuleIndex = YQLParserRULE_window_frame_clause return p } @@ -78332,13 +78332,13 @@ func (s *Window_frame_clauseContext) ToStringTree(ruleNames []string, recog antl func (s *Window_frame_clauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_frame_clause(s) } } func (s *Window_frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_frame_clause(s) } } @@ -78346,9 +78346,9 @@ func (s *Window_frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Window_frame_clause() (localctx IWindow_frame_clauseContext) { +func (p *YQLParser) Window_frame_clause() (localctx IWindow_frame_clauseContext) { localctx = NewWindow_frame_clauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 748, YQLv1Antlr4ParserRULE_window_frame_clause) + p.EnterRule(localctx, 748, YQLParserRULE_window_frame_clause) var _la int p.EnterOuterAlt(localctx, 1) @@ -78368,7 +78368,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_clause() (localctx IWindow_frame_clause _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserEXCLUDE { + if _la == YQLParserEXCLUDE { { p.SetState(4267) p.Window_frame_exclusion() @@ -78416,13 +78416,13 @@ type Window_frame_unitsContext struct { func NewEmptyWindow_frame_unitsContext() *Window_frame_unitsContext { var p = new(Window_frame_unitsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_units + p.RuleIndex = YQLParserRULE_window_frame_units return p } func InitEmptyWindow_frame_unitsContext(p *Window_frame_unitsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_units + p.RuleIndex = YQLParserRULE_window_frame_units } func (*Window_frame_unitsContext) IsWindow_frame_unitsContext() {} @@ -78433,7 +78433,7 @@ func NewWindow_frame_unitsContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_units + p.RuleIndex = YQLParserRULE_window_frame_units return p } @@ -78441,15 +78441,15 @@ func NewWindow_frame_unitsContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Window_frame_unitsContext) GetParser() antlr.Parser { return s.parser } func (s *Window_frame_unitsContext) ROWS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROWS, 0) + return s.GetToken(YQLParserROWS, 0) } func (s *Window_frame_unitsContext) RANGE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRANGE, 0) + return s.GetToken(YQLParserRANGE, 0) } func (s *Window_frame_unitsContext) GROUPS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUPS, 0) + return s.GetToken(YQLParserGROUPS, 0) } func (s *Window_frame_unitsContext) GetRuleContext() antlr.RuleContext { @@ -78462,13 +78462,13 @@ func (s *Window_frame_unitsContext) ToStringTree(ruleNames []string, recog antlr func (s *Window_frame_unitsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_frame_units(s) } } func (s *Window_frame_unitsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_frame_units(s) } } @@ -78476,9 +78476,9 @@ func (s *Window_frame_unitsContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Window_frame_units() (localctx IWindow_frame_unitsContext) { +func (p *YQLParser) Window_frame_units() (localctx IWindow_frame_unitsContext) { localctx = NewWindow_frame_unitsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 750, YQLv1Antlr4ParserRULE_window_frame_units) + p.EnterRule(localctx, 750, YQLParserRULE_window_frame_units) var _la int p.EnterOuterAlt(localctx, 1) @@ -78486,7 +78486,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_units() (localctx IWindow_frame_unitsCo p.SetState(4270) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserGROUPS || _la == YQLv1Antlr4ParserRANGE || _la == YQLv1Antlr4ParserROWS) { + if !(_la == YQLParserGROUPS || _la == YQLParserRANGE || _la == YQLParserROWS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -78533,13 +78533,13 @@ type Window_frame_extentContext struct { func NewEmptyWindow_frame_extentContext() *Window_frame_extentContext { var p = new(Window_frame_extentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_extent + p.RuleIndex = YQLParserRULE_window_frame_extent return p } func InitEmptyWindow_frame_extentContext(p *Window_frame_extentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_extent + p.RuleIndex = YQLParserRULE_window_frame_extent } func (*Window_frame_extentContext) IsWindow_frame_extentContext() {} @@ -78550,7 +78550,7 @@ func NewWindow_frame_extentContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_extent + p.RuleIndex = YQLParserRULE_window_frame_extent return p } @@ -78599,13 +78599,13 @@ func (s *Window_frame_extentContext) ToStringTree(ruleNames []string, recog antl func (s *Window_frame_extentContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_frame_extent(s) } } func (s *Window_frame_extentContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_frame_extent(s) } } @@ -78613,9 +78613,9 @@ func (s *Window_frame_extentContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Window_frame_extent() (localctx IWindow_frame_extentContext) { +func (p *YQLParser) Window_frame_extent() (localctx IWindow_frame_extentContext) { localctx = NewWindow_frame_extentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 752, YQLv1Antlr4ParserRULE_window_frame_extent) + p.EnterRule(localctx, 752, YQLParserRULE_window_frame_extent) p.SetState(4274) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -78682,13 +78682,13 @@ type Window_frame_betweenContext struct { func NewEmptyWindow_frame_betweenContext() *Window_frame_betweenContext { var p = new(Window_frame_betweenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_between + p.RuleIndex = YQLParserRULE_window_frame_between return p } func InitEmptyWindow_frame_betweenContext(p *Window_frame_betweenContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_between + p.RuleIndex = YQLParserRULE_window_frame_between } func (*Window_frame_betweenContext) IsWindow_frame_betweenContext() {} @@ -78699,7 +78699,7 @@ func NewWindow_frame_betweenContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_between + p.RuleIndex = YQLParserRULE_window_frame_between return p } @@ -78707,7 +78707,7 @@ func NewWindow_frame_betweenContext(parser antlr.Parser, parent antlr.ParserRule func (s *Window_frame_betweenContext) GetParser() antlr.Parser { return s.parser } func (s *Window_frame_betweenContext) BETWEEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBETWEEN, 0) + return s.GetToken(YQLParserBETWEEN, 0) } func (s *Window_frame_betweenContext) AllWindow_frame_bound() []IWindow_frame_boundContext { @@ -78752,7 +78752,7 @@ func (s *Window_frame_betweenContext) Window_frame_bound(i int) IWindow_frame_bo } func (s *Window_frame_betweenContext) AND() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAND, 0) + return s.GetToken(YQLParserAND, 0) } func (s *Window_frame_betweenContext) GetRuleContext() antlr.RuleContext { @@ -78765,13 +78765,13 @@ func (s *Window_frame_betweenContext) ToStringTree(ruleNames []string, recog ant func (s *Window_frame_betweenContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_frame_between(s) } } func (s *Window_frame_betweenContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_frame_between(s) } } @@ -78779,13 +78779,13 @@ func (s *Window_frame_betweenContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Window_frame_between() (localctx IWindow_frame_betweenContext) { +func (p *YQLParser) Window_frame_between() (localctx IWindow_frame_betweenContext) { localctx = NewWindow_frame_betweenContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 754, YQLv1Antlr4ParserRULE_window_frame_between) + p.EnterRule(localctx, 754, YQLParserRULE_window_frame_between) p.EnterOuterAlt(localctx, 1) { p.SetState(4276) - p.Match(YQLv1Antlr4ParserBETWEEN) + p.Match(YQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78797,7 +78797,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_between() (localctx IWindow_frame_betwe } { p.SetState(4278) - p.Match(YQLv1Antlr4ParserAND) + p.Match(YQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78851,13 +78851,13 @@ type Window_frame_boundContext struct { func NewEmptyWindow_frame_boundContext() *Window_frame_boundContext { var p = new(Window_frame_boundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_bound + p.RuleIndex = YQLParserRULE_window_frame_bound return p } func InitEmptyWindow_frame_boundContext(p *Window_frame_boundContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_bound + p.RuleIndex = YQLParserRULE_window_frame_bound } func (*Window_frame_boundContext) IsWindow_frame_boundContext() {} @@ -78868,7 +78868,7 @@ func NewWindow_frame_boundContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_bound + p.RuleIndex = YQLParserRULE_window_frame_bound return p } @@ -78876,19 +78876,19 @@ func NewWindow_frame_boundContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *Window_frame_boundContext) GetParser() antlr.Parser { return s.parser } func (s *Window_frame_boundContext) CURRENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT, 0) + return s.GetToken(YQLParserCURRENT, 0) } func (s *Window_frame_boundContext) ROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROW, 0) + return s.GetToken(YQLParserROW, 0) } func (s *Window_frame_boundContext) PRECEDING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRECEDING, 0) + return s.GetToken(YQLParserPRECEDING, 0) } func (s *Window_frame_boundContext) FOLLOWING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOLLOWING, 0) + return s.GetToken(YQLParserFOLLOWING, 0) } func (s *Window_frame_boundContext) Expr() IExprContext { @@ -78908,7 +78908,7 @@ func (s *Window_frame_boundContext) Expr() IExprContext { } func (s *Window_frame_boundContext) UNBOUNDED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNBOUNDED, 0) + return s.GetToken(YQLParserUNBOUNDED, 0) } func (s *Window_frame_boundContext) GetRuleContext() antlr.RuleContext { @@ -78921,13 +78921,13 @@ func (s *Window_frame_boundContext) ToStringTree(ruleNames []string, recog antlr func (s *Window_frame_boundContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_frame_bound(s) } } func (s *Window_frame_boundContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_frame_bound(s) } } @@ -78935,9 +78935,9 @@ func (s *Window_frame_boundContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Window_frame_bound() (localctx IWindow_frame_boundContext) { +func (p *YQLParser) Window_frame_bound() (localctx IWindow_frame_boundContext) { localctx = NewWindow_frame_boundContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 756, YQLv1Antlr4ParserRULE_window_frame_bound) + p.EnterRule(localctx, 756, YQLParserRULE_window_frame_bound) var _la int p.SetState(4288) @@ -78951,7 +78951,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_bound() (localctx IWindow_frame_boundCo p.EnterOuterAlt(localctx, 1) { p.SetState(4281) - p.Match(YQLv1Antlr4ParserCURRENT) + p.Match(YQLParserCURRENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78959,7 +78959,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_bound() (localctx IWindow_frame_boundCo } { p.SetState(4282) - p.Match(YQLv1Antlr4ParserROW) + p.Match(YQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78986,7 +78986,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_bound() (localctx IWindow_frame_boundCo case 2: { p.SetState(4284) - p.Match(YQLv1Antlr4ParserUNBOUNDED) + p.Match(YQLParserUNBOUNDED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79000,7 +79000,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_bound() (localctx IWindow_frame_boundCo p.SetState(4287) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserFOLLOWING || _la == YQLv1Antlr4ParserPRECEDING) { + if !(_la == YQLParserFOLLOWING || _la == YQLParserPRECEDING) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -79055,13 +79055,13 @@ type Window_frame_exclusionContext struct { func NewEmptyWindow_frame_exclusionContext() *Window_frame_exclusionContext { var p = new(Window_frame_exclusionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_exclusion + p.RuleIndex = YQLParserRULE_window_frame_exclusion return p } func InitEmptyWindow_frame_exclusionContext(p *Window_frame_exclusionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_exclusion + p.RuleIndex = YQLParserRULE_window_frame_exclusion } func (*Window_frame_exclusionContext) IsWindow_frame_exclusionContext() {} @@ -79072,7 +79072,7 @@ func NewWindow_frame_exclusionContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_window_frame_exclusion + p.RuleIndex = YQLParserRULE_window_frame_exclusion return p } @@ -79080,31 +79080,31 @@ func NewWindow_frame_exclusionContext(parser antlr.Parser, parent antlr.ParserRu func (s *Window_frame_exclusionContext) GetParser() antlr.Parser { return s.parser } func (s *Window_frame_exclusionContext) EXCLUDE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCLUDE, 0) + return s.GetToken(YQLParserEXCLUDE, 0) } func (s *Window_frame_exclusionContext) CURRENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT, 0) + return s.GetToken(YQLParserCURRENT, 0) } func (s *Window_frame_exclusionContext) ROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROW, 0) + return s.GetToken(YQLParserROW, 0) } func (s *Window_frame_exclusionContext) GROUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUP, 0) + return s.GetToken(YQLParserGROUP, 0) } func (s *Window_frame_exclusionContext) TIES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTIES, 0) + return s.GetToken(YQLParserTIES, 0) } func (s *Window_frame_exclusionContext) NO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNO, 0) + return s.GetToken(YQLParserNO, 0) } func (s *Window_frame_exclusionContext) OTHERS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOTHERS, 0) + return s.GetToken(YQLParserOTHERS, 0) } func (s *Window_frame_exclusionContext) GetRuleContext() antlr.RuleContext { @@ -79117,13 +79117,13 @@ func (s *Window_frame_exclusionContext) ToStringTree(ruleNames []string, recog a func (s *Window_frame_exclusionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterWindow_frame_exclusion(s) } } func (s *Window_frame_exclusionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitWindow_frame_exclusion(s) } } @@ -79131,9 +79131,9 @@ func (s *Window_frame_exclusionContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exclusionContext) { +func (p *YQLParser) Window_frame_exclusion() (localctx IWindow_frame_exclusionContext) { localctx = NewWindow_frame_exclusionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 758, YQLv1Antlr4ParserRULE_window_frame_exclusion) + p.EnterRule(localctx, 758, YQLParserRULE_window_frame_exclusion) p.SetState(4300) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -79145,7 +79145,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc p.EnterOuterAlt(localctx, 1) { p.SetState(4290) - p.Match(YQLv1Antlr4ParserEXCLUDE) + p.Match(YQLParserEXCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79153,7 +79153,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc } { p.SetState(4291) - p.Match(YQLv1Antlr4ParserCURRENT) + p.Match(YQLParserCURRENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79161,7 +79161,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc } { p.SetState(4292) - p.Match(YQLv1Antlr4ParserROW) + p.Match(YQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79173,7 +79173,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc p.EnterOuterAlt(localctx, 2) { p.SetState(4293) - p.Match(YQLv1Antlr4ParserEXCLUDE) + p.Match(YQLParserEXCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79181,7 +79181,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc } { p.SetState(4294) - p.Match(YQLv1Antlr4ParserGROUP) + p.Match(YQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79193,7 +79193,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc p.EnterOuterAlt(localctx, 3) { p.SetState(4295) - p.Match(YQLv1Antlr4ParserEXCLUDE) + p.Match(YQLParserEXCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79201,7 +79201,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc } { p.SetState(4296) - p.Match(YQLv1Antlr4ParserTIES) + p.Match(YQLParserTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79213,7 +79213,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc p.EnterOuterAlt(localctx, 4) { p.SetState(4297) - p.Match(YQLv1Antlr4ParserEXCLUDE) + p.Match(YQLParserEXCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79221,7 +79221,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc } { p.SetState(4298) - p.Match(YQLv1Antlr4ParserNO) + p.Match(YQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79229,7 +79229,7 @@ func (p *YQLv1Antlr4Parser) Window_frame_exclusion() (localctx IWindow_frame_exc } { p.SetState(4299) - p.Match(YQLv1Antlr4ParserOTHERS) + p.Match(YQLParserOTHERS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79278,13 +79278,13 @@ type Use_stmtContext struct { func NewEmptyUse_stmtContext() *Use_stmtContext { var p = new(Use_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_use_stmt + p.RuleIndex = YQLParserRULE_use_stmt return p } func InitEmptyUse_stmtContext(p *Use_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_use_stmt + p.RuleIndex = YQLParserRULE_use_stmt } func (*Use_stmtContext) IsUse_stmtContext() {} @@ -79295,7 +79295,7 @@ func NewUse_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_use_stmt + p.RuleIndex = YQLParserRULE_use_stmt return p } @@ -79303,7 +79303,7 @@ func NewUse_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *Use_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Use_stmtContext) USE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSE, 0) + return s.GetToken(YQLParserUSE, 0) } func (s *Use_stmtContext) Cluster_expr() ICluster_exprContext { @@ -79332,13 +79332,13 @@ func (s *Use_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *Use_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterUse_stmt(s) } } func (s *Use_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitUse_stmt(s) } } @@ -79346,13 +79346,13 @@ func (s *Use_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Use_stmt() (localctx IUse_stmtContext) { +func (p *YQLParser) Use_stmt() (localctx IUse_stmtContext) { localctx = NewUse_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 760, YQLv1Antlr4ParserRULE_use_stmt) + p.EnterRule(localctx, 760, YQLParserRULE_use_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4302) - p.Match(YQLv1Antlr4ParserUSE) + p.Match(YQLParserUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79404,13 +79404,13 @@ type Subselect_stmtContext struct { func NewEmptySubselect_stmtContext() *Subselect_stmtContext { var p = new(Subselect_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_subselect_stmt + p.RuleIndex = YQLParserRULE_subselect_stmt return p } func InitEmptySubselect_stmtContext(p *Subselect_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_subselect_stmt + p.RuleIndex = YQLParserRULE_subselect_stmt } func (*Subselect_stmtContext) IsSubselect_stmtContext() {} @@ -79421,7 +79421,7 @@ func NewSubselect_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_subselect_stmt + p.RuleIndex = YQLParserRULE_subselect_stmt return p } @@ -79429,7 +79429,7 @@ func NewSubselect_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Subselect_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Subselect_stmtContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Subselect_stmtContext) Select_stmt() ISelect_stmtContext { @@ -79449,7 +79449,7 @@ func (s *Subselect_stmtContext) Select_stmt() ISelect_stmtContext { } func (s *Subselect_stmtContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Subselect_stmtContext) Select_unparenthesized_stmt() ISelect_unparenthesized_stmtContext { @@ -79478,13 +79478,13 @@ func (s *Subselect_stmtContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Subselect_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterSubselect_stmt(s) } } func (s *Subselect_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitSubselect_stmt(s) } } @@ -79492,9 +79492,9 @@ func (s *Subselect_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Subselect_stmt() (localctx ISubselect_stmtContext) { +func (p *YQLParser) Subselect_stmt() (localctx ISubselect_stmtContext) { localctx = NewSubselect_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 762, YQLv1Antlr4ParserRULE_subselect_stmt) + p.EnterRule(localctx, 762, YQLParserRULE_subselect_stmt) p.EnterOuterAlt(localctx, 1) p.SetState(4310) p.GetErrorHandler().Sync(p) @@ -79503,10 +79503,10 @@ func (p *YQLv1Antlr4Parser) Subselect_stmt() (localctx ISubselect_stmtContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserLPAREN: + case YQLParserLPAREN: { p.SetState(4305) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79518,7 +79518,7 @@ func (p *YQLv1Antlr4Parser) Subselect_stmt() (localctx ISubselect_stmtContext) { } { p.SetState(4307) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79526,7 +79526,7 @@ func (p *YQLv1Antlr4Parser) Subselect_stmt() (localctx ISubselect_stmtContext) { } - case YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserSELECT: + case YQLParserDISCARD, YQLParserFROM, YQLParserPROCESS, YQLParserREDUCE, YQLParserSELECT: { p.SetState(4309) p.Select_unparenthesized_stmt() @@ -79580,13 +79580,13 @@ type Named_nodes_stmtContext struct { func NewEmptyNamed_nodes_stmtContext() *Named_nodes_stmtContext { var p = new(Named_nodes_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_nodes_stmt + p.RuleIndex = YQLParserRULE_named_nodes_stmt return p } func InitEmptyNamed_nodes_stmtContext(p *Named_nodes_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_named_nodes_stmt + p.RuleIndex = YQLParserRULE_named_nodes_stmt } func (*Named_nodes_stmtContext) IsNamed_nodes_stmtContext() {} @@ -79597,7 +79597,7 @@ func NewNamed_nodes_stmtContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_named_nodes_stmt + p.RuleIndex = YQLParserRULE_named_nodes_stmt return p } @@ -79621,7 +79621,7 @@ func (s *Named_nodes_stmtContext) Bind_parameter_list() IBind_parameter_listCont } func (s *Named_nodes_stmtContext) EQUALS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEQUALS, 0) + return s.GetToken(YQLParserEQUALS, 0) } func (s *Named_nodes_stmtContext) Expr() IExprContext { @@ -79666,13 +79666,13 @@ func (s *Named_nodes_stmtContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Named_nodes_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterNamed_nodes_stmt(s) } } func (s *Named_nodes_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitNamed_nodes_stmt(s) } } @@ -79680,9 +79680,9 @@ func (s *Named_nodes_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Named_nodes_stmt() (localctx INamed_nodes_stmtContext) { +func (p *YQLParser) Named_nodes_stmt() (localctx INamed_nodes_stmtContext) { localctx = NewNamed_nodes_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 764, YQLv1Antlr4ParserRULE_named_nodes_stmt) + p.EnterRule(localctx, 764, YQLParserRULE_named_nodes_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4312) @@ -79690,7 +79690,7 @@ func (p *YQLv1Antlr4Parser) Named_nodes_stmt() (localctx INamed_nodes_stmtContex } { p.SetState(4313) - p.Match(YQLv1Antlr4ParserEQUALS) + p.Match(YQLParserEQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79758,13 +79758,13 @@ type Commit_stmtContext struct { func NewEmptyCommit_stmtContext() *Commit_stmtContext { var p = new(Commit_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_commit_stmt + p.RuleIndex = YQLParserRULE_commit_stmt return p } func InitEmptyCommit_stmtContext(p *Commit_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_commit_stmt + p.RuleIndex = YQLParserRULE_commit_stmt } func (*Commit_stmtContext) IsCommit_stmtContext() {} @@ -79775,7 +79775,7 @@ func NewCommit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_commit_stmt + p.RuleIndex = YQLParserRULE_commit_stmt return p } @@ -79783,7 +79783,7 @@ func NewCommit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Commit_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Commit_stmtContext) COMMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMIT, 0) + return s.GetToken(YQLParserCOMMIT, 0) } func (s *Commit_stmtContext) GetRuleContext() antlr.RuleContext { @@ -79796,13 +79796,13 @@ func (s *Commit_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *Commit_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCommit_stmt(s) } } func (s *Commit_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCommit_stmt(s) } } @@ -79810,13 +79810,13 @@ func (s *Commit_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Commit_stmt() (localctx ICommit_stmtContext) { +func (p *YQLParser) Commit_stmt() (localctx ICommit_stmtContext) { localctx = NewCommit_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 766, YQLv1Antlr4ParserRULE_commit_stmt) + p.EnterRule(localctx, 766, YQLParserRULE_commit_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4318) - p.Match(YQLv1Antlr4ParserCOMMIT) + p.Match(YQLParserCOMMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79861,13 +79861,13 @@ type Rollback_stmtContext struct { func NewEmptyRollback_stmtContext() *Rollback_stmtContext { var p = new(Rollback_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_rollback_stmt + p.RuleIndex = YQLParserRULE_rollback_stmt return p } func InitEmptyRollback_stmtContext(p *Rollback_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_rollback_stmt + p.RuleIndex = YQLParserRULE_rollback_stmt } func (*Rollback_stmtContext) IsRollback_stmtContext() {} @@ -79878,7 +79878,7 @@ func NewRollback_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_rollback_stmt + p.RuleIndex = YQLParserRULE_rollback_stmt return p } @@ -79886,7 +79886,7 @@ func NewRollback_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *Rollback_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Rollback_stmtContext) ROLLBACK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROLLBACK, 0) + return s.GetToken(YQLParserROLLBACK, 0) } func (s *Rollback_stmtContext) GetRuleContext() antlr.RuleContext { @@ -79899,13 +79899,13 @@ func (s *Rollback_stmtContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Rollback_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterRollback_stmt(s) } } func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitRollback_stmt(s) } } @@ -79913,13 +79913,13 @@ func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Rollback_stmt() (localctx IRollback_stmtContext) { +func (p *YQLParser) Rollback_stmt() (localctx IRollback_stmtContext) { localctx = NewRollback_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 768, YQLv1Antlr4ParserRULE_rollback_stmt) + p.EnterRule(localctx, 768, YQLParserRULE_rollback_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4320) - p.Match(YQLv1Antlr4ParserROLLBACK) + p.Match(YQLParserROLLBACK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79967,13 +79967,13 @@ type Analyze_tableContext struct { func NewEmptyAnalyze_tableContext() *Analyze_tableContext { var p = new(Analyze_tableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_table + p.RuleIndex = YQLParserRULE_analyze_table return p } func InitEmptyAnalyze_tableContext(p *Analyze_tableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_table + p.RuleIndex = YQLParserRULE_analyze_table } func (*Analyze_tableContext) IsAnalyze_tableContext() {} @@ -79984,7 +79984,7 @@ func NewAnalyze_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_table + p.RuleIndex = YQLParserRULE_analyze_table return p } @@ -80008,7 +80008,7 @@ func (s *Analyze_tableContext) Simple_table_ref() ISimple_table_refContext { } func (s *Analyze_tableContext) LPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLPAREN, 0) + return s.GetToken(YQLParserLPAREN, 0) } func (s *Analyze_tableContext) Column_list() IColumn_listContext { @@ -80028,7 +80028,7 @@ func (s *Analyze_tableContext) Column_list() IColumn_listContext { } func (s *Analyze_tableContext) RPAREN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRPAREN, 0) + return s.GetToken(YQLParserRPAREN, 0) } func (s *Analyze_tableContext) GetRuleContext() antlr.RuleContext { @@ -80041,13 +80041,13 @@ func (s *Analyze_tableContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Analyze_tableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAnalyze_table(s) } } func (s *Analyze_tableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAnalyze_table(s) } } @@ -80055,9 +80055,9 @@ func (s *Analyze_tableContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Analyze_table() (localctx IAnalyze_tableContext) { +func (p *YQLParser) Analyze_table() (localctx IAnalyze_tableContext) { localctx = NewAnalyze_tableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 770, YQLv1Antlr4ParserRULE_analyze_table) + p.EnterRule(localctx, 770, YQLParserRULE_analyze_table) var _la int p.EnterOuterAlt(localctx, 1) @@ -80073,10 +80073,10 @@ func (p *YQLv1Antlr4Parser) Analyze_table() (localctx IAnalyze_tableContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserLPAREN { + if _la == YQLParserLPAREN { { p.SetState(4323) - p.Match(YQLv1Antlr4ParserLPAREN) + p.Match(YQLParserLPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80088,7 +80088,7 @@ func (p *YQLv1Antlr4Parser) Analyze_table() (localctx IAnalyze_tableContext) { } { p.SetState(4325) - p.Match(YQLv1Antlr4ParserRPAREN) + p.Match(YQLParserRPAREN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80138,13 +80138,13 @@ type Analyze_table_listContext struct { func NewEmptyAnalyze_table_listContext() *Analyze_table_listContext { var p = new(Analyze_table_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_table_list + p.RuleIndex = YQLParserRULE_analyze_table_list return p } func InitEmptyAnalyze_table_listContext(p *Analyze_table_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_table_list + p.RuleIndex = YQLParserRULE_analyze_table_list } func (*Analyze_table_listContext) IsAnalyze_table_listContext() {} @@ -80155,7 +80155,7 @@ func NewAnalyze_table_listContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_table_list + p.RuleIndex = YQLParserRULE_analyze_table_list return p } @@ -80204,11 +80204,11 @@ func (s *Analyze_table_listContext) Analyze_table(i int) IAnalyze_tableContext { } func (s *Analyze_table_listContext) AllCOMMA() []antlr.TerminalNode { - return s.GetTokens(YQLv1Antlr4ParserCOMMA) + return s.GetTokens(YQLParserCOMMA) } func (s *Analyze_table_listContext) COMMA(i int) antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMA, i) + return s.GetToken(YQLParserCOMMA, i) } func (s *Analyze_table_listContext) GetRuleContext() antlr.RuleContext { @@ -80221,13 +80221,13 @@ func (s *Analyze_table_listContext) ToStringTree(ruleNames []string, recog antlr func (s *Analyze_table_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAnalyze_table_list(s) } } func (s *Analyze_table_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAnalyze_table_list(s) } } @@ -80235,9 +80235,9 @@ func (s *Analyze_table_listContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Analyze_table_list() (localctx IAnalyze_table_listContext) { +func (p *YQLParser) Analyze_table_list() (localctx IAnalyze_table_listContext) { localctx = NewAnalyze_table_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 772, YQLv1Antlr4ParserRULE_analyze_table_list) + p.EnterRule(localctx, 772, YQLParserRULE_analyze_table_list) var _la int var _alt int @@ -80260,7 +80260,7 @@ func (p *YQLv1Antlr4Parser) Analyze_table_list() (localctx IAnalyze_table_listCo if _alt == 1 { { p.SetState(4330) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80291,10 +80291,10 @@ func (p *YQLv1Antlr4Parser) Analyze_table_list() (localctx IAnalyze_table_listCo _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMA { + if _la == YQLParserCOMMA { { p.SetState(4337) - p.Match(YQLv1Antlr4ParserCOMMA) + p.Match(YQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80342,13 +80342,13 @@ type Analyze_stmtContext struct { func NewEmptyAnalyze_stmtContext() *Analyze_stmtContext { var p = new(Analyze_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_stmt + p.RuleIndex = YQLParserRULE_analyze_stmt return p } func InitEmptyAnalyze_stmtContext(p *Analyze_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_stmt + p.RuleIndex = YQLParserRULE_analyze_stmt } func (*Analyze_stmtContext) IsAnalyze_stmtContext() {} @@ -80359,7 +80359,7 @@ func NewAnalyze_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_analyze_stmt + p.RuleIndex = YQLParserRULE_analyze_stmt return p } @@ -80367,7 +80367,7 @@ func NewAnalyze_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Analyze_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Analyze_stmtContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANALYZE, 0) + return s.GetToken(YQLParserANALYZE, 0) } func (s *Analyze_stmtContext) Analyze_table_list() IAnalyze_table_listContext { @@ -80396,13 +80396,13 @@ func (s *Analyze_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Analyze_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAnalyze_stmt(s) } } func (s *Analyze_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAnalyze_stmt(s) } } @@ -80410,13 +80410,13 @@ func (s *Analyze_stmtContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Analyze_stmt() (localctx IAnalyze_stmtContext) { +func (p *YQLParser) Analyze_stmt() (localctx IAnalyze_stmtContext) { localctx = NewAnalyze_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 774, YQLv1Antlr4ParserRULE_analyze_stmt) + p.EnterRule(localctx, 774, YQLParserRULE_analyze_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4340) - p.Match(YQLv1Antlr4ParserANALYZE) + p.Match(YQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80471,13 +80471,13 @@ type Alter_sequence_stmtContext struct { func NewEmptyAlter_sequence_stmtContext() *Alter_sequence_stmtContext { var p = new(Alter_sequence_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_sequence_stmt + p.RuleIndex = YQLParserRULE_alter_sequence_stmt return p } func InitEmptyAlter_sequence_stmtContext(p *Alter_sequence_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_sequence_stmt + p.RuleIndex = YQLParserRULE_alter_sequence_stmt } func (*Alter_sequence_stmtContext) IsAlter_sequence_stmtContext() {} @@ -80488,7 +80488,7 @@ func NewAlter_sequence_stmtContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_sequence_stmt + p.RuleIndex = YQLParserRULE_alter_sequence_stmt return p } @@ -80496,11 +80496,11 @@ func NewAlter_sequence_stmtContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *Alter_sequence_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_sequence_stmtContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Alter_sequence_stmtContext) SEQUENCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEQUENCE, 0) + return s.GetToken(YQLParserSEQUENCE, 0) } func (s *Alter_sequence_stmtContext) Object_ref() IObject_refContext { @@ -80520,11 +80520,11 @@ func (s *Alter_sequence_stmtContext) Object_ref() IObject_refContext { } func (s *Alter_sequence_stmtContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Alter_sequence_stmtContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Alter_sequence_stmtContext) AllAlter_sequence_action() []IAlter_sequence_actionContext { @@ -80578,13 +80578,13 @@ func (s *Alter_sequence_stmtContext) ToStringTree(ruleNames []string, recog antl func (s *Alter_sequence_stmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_sequence_stmt(s) } } func (s *Alter_sequence_stmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_sequence_stmt(s) } } @@ -80592,15 +80592,15 @@ func (s *Alter_sequence_stmtContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Alter_sequence_stmt() (localctx IAlter_sequence_stmtContext) { +func (p *YQLParser) Alter_sequence_stmt() (localctx IAlter_sequence_stmtContext) { localctx = NewAlter_sequence_stmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 776, YQLv1Antlr4ParserRULE_alter_sequence_stmt) + p.EnterRule(localctx, 776, YQLParserRULE_alter_sequence_stmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4343) - p.Match(YQLv1Antlr4ParserALTER) + p.Match(YQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80608,7 +80608,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_stmt() (localctx IAlter_sequence_stmt } { p.SetState(4344) - p.Match(YQLv1Antlr4ParserSEQUENCE) + p.Match(YQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80621,7 +80621,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_stmt() (localctx IAlter_sequence_stmt if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 469, p.GetParserRuleContext()) == 1 { { p.SetState(4345) - p.Match(YQLv1Antlr4ParserIF) + p.Match(YQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80629,7 +80629,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_stmt() (localctx IAlter_sequence_stmt } { p.SetState(4346) - p.Match(YQLv1Antlr4ParserEXISTS) + p.Match(YQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80651,7 +80651,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_stmt() (localctx IAlter_sequence_stmt _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == YQLv1Antlr4ParserINCREMENT || _la == YQLv1Antlr4ParserRESTART || _la == YQLv1Antlr4ParserSTART { + for ok := true; ok; ok = _la == YQLParserINCREMENT || _la == YQLParserRESTART || _la == YQLParserSTART { { p.SetState(4350) p.Alter_sequence_action() @@ -80709,13 +80709,13 @@ type Alter_sequence_actionContext struct { func NewEmptyAlter_sequence_actionContext() *Alter_sequence_actionContext { var p = new(Alter_sequence_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_sequence_action + p.RuleIndex = YQLParserRULE_alter_sequence_action return p } func InitEmptyAlter_sequence_actionContext(p *Alter_sequence_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_sequence_action + p.RuleIndex = YQLParserRULE_alter_sequence_action } func (*Alter_sequence_actionContext) IsAlter_sequence_actionContext() {} @@ -80726,7 +80726,7 @@ func NewAlter_sequence_actionContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_alter_sequence_action + p.RuleIndex = YQLParserRULE_alter_sequence_action return p } @@ -80734,7 +80734,7 @@ func NewAlter_sequence_actionContext(parser antlr.Parser, parent antlr.ParserRul func (s *Alter_sequence_actionContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_sequence_actionContext) START() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTART, 0) + return s.GetToken(YQLParserSTART, 0) } func (s *Alter_sequence_actionContext) Integer() IIntegerContext { @@ -80754,19 +80754,19 @@ func (s *Alter_sequence_actionContext) Integer() IIntegerContext { } func (s *Alter_sequence_actionContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Alter_sequence_actionContext) RESTART() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTART, 0) + return s.GetToken(YQLParserRESTART, 0) } func (s *Alter_sequence_actionContext) INCREMENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINCREMENT, 0) + return s.GetToken(YQLParserINCREMENT, 0) } func (s *Alter_sequence_actionContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Alter_sequence_actionContext) GetRuleContext() antlr.RuleContext { @@ -80779,13 +80779,13 @@ func (s *Alter_sequence_actionContext) ToStringTree(ruleNames []string, recog an func (s *Alter_sequence_actionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAlter_sequence_action(s) } } func (s *Alter_sequence_actionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAlter_sequence_action(s) } } @@ -80793,9 +80793,9 @@ func (s *Alter_sequence_actionContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_actionContext) { +func (p *YQLParser) Alter_sequence_action() (localctx IAlter_sequence_actionContext) { localctx = NewAlter_sequence_actionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 778, YQLv1Antlr4ParserRULE_alter_sequence_action) + p.EnterRule(localctx, 778, YQLParserRULE_alter_sequence_action) var _la int p.SetState(4371) @@ -80809,7 +80809,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_ac p.EnterOuterAlt(localctx, 1) { p.SetState(4355) - p.Match(YQLv1Antlr4ParserSTART) + p.Match(YQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80823,10 +80823,10 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_ac _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(4356) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80844,7 +80844,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_ac p.EnterOuterAlt(localctx, 2) { p.SetState(4360) - p.Match(YQLv1Antlr4ParserRESTART) + p.Match(YQLParserRESTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80858,10 +80858,10 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_ac _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserWITH { + if _la == YQLParserWITH { { p.SetState(4361) - p.Match(YQLv1Antlr4ParserWITH) + p.Match(YQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80879,7 +80879,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_ac p.EnterOuterAlt(localctx, 3) { p.SetState(4365) - p.Match(YQLv1Antlr4ParserRESTART) + p.Match(YQLParserRESTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80891,7 +80891,7 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_ac p.EnterOuterAlt(localctx, 4) { p.SetState(4366) - p.Match(YQLv1Antlr4ParserINCREMENT) + p.Match(YQLParserINCREMENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80905,10 +80905,10 @@ func (p *YQLv1Antlr4Parser) Alter_sequence_action() (localctx IAlter_sequence_ac _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserBY { + if _la == YQLParserBY { { p.SetState(4367) - p.Match(YQLv1Antlr4ParserBY) + p.Match(YQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80963,13 +80963,13 @@ type IdentifierContext struct { func NewEmptyIdentifierContext() *IdentifierContext { var p = new(IdentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_identifier + p.RuleIndex = YQLParserRULE_identifier return p } func InitEmptyIdentifierContext(p *IdentifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_identifier + p.RuleIndex = YQLParserRULE_identifier } func (*IdentifierContext) IsIdentifierContext() {} @@ -80980,7 +80980,7 @@ func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_identifier + p.RuleIndex = YQLParserRULE_identifier return p } @@ -80988,11 +80988,11 @@ func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } func (s *IdentifierContext) ID_PLAIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserID_PLAIN, 0) + return s.GetToken(YQLParserID_PLAIN, 0) } func (s *IdentifierContext) ID_QUOTED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserID_QUOTED, 0) + return s.GetToken(YQLParserID_QUOTED, 0) } func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { @@ -81005,13 +81005,13 @@ func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterIdentifier(s) } } func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitIdentifier(s) } } @@ -81019,9 +81019,9 @@ func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Identifier() (localctx IIdentifierContext) { +func (p *YQLParser) Identifier() (localctx IIdentifierContext) { localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 780, YQLv1Antlr4ParserRULE_identifier) + p.EnterRule(localctx, 780, YQLParserRULE_identifier) var _la int p.EnterOuterAlt(localctx, 1) @@ -81029,7 +81029,7 @@ func (p *YQLv1Antlr4Parser) Identifier() (localctx IIdentifierContext) { p.SetState(4373) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserID_PLAIN || _la == YQLv1Antlr4ParserID_QUOTED) { + if !(_la == YQLParserID_PLAIN || _la == YQLParserID_QUOTED) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -81076,13 +81076,13 @@ type IdContext struct { func NewEmptyIdContext() *IdContext { var p = new(IdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id + p.RuleIndex = YQLParserRULE_id return p } func InitEmptyIdContext(p *IdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id + p.RuleIndex = YQLParserRULE_id } func (*IdContext) IsIdContext() {} @@ -81093,7 +81093,7 @@ func NewIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingS antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id + p.RuleIndex = YQLParserRULE_id return p } @@ -81142,13 +81142,13 @@ func (s *IdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) str func (s *IdContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId(s) } } func (s *IdContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId(s) } } @@ -81156,9 +81156,9 @@ func (s *IdContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id() (localctx IIdContext) { +func (p *YQLParser) Id() (localctx IIdContext) { localctx = NewIdContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 782, YQLv1Antlr4ParserRULE_id) + p.EnterRule(localctx, 782, YQLParserRULE_id) p.SetState(4377) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -81166,7 +81166,7 @@ func (p *YQLv1Antlr4Parser) Id() (localctx IIdContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4375) @@ -81174,7 +81174,7 @@ func (p *YQLv1Antlr4Parser) Id() (localctx IIdContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4376) @@ -81231,13 +81231,13 @@ type Id_schemaContext struct { func NewEmptyId_schemaContext() *Id_schemaContext { var p = new(Id_schemaContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_schema + p.RuleIndex = YQLParserRULE_id_schema return p } func InitEmptyId_schemaContext(p *Id_schemaContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_schema + p.RuleIndex = YQLParserRULE_id_schema } func (*Id_schemaContext) IsId_schemaContext() {} @@ -81248,7 +81248,7 @@ func NewId_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_schema + p.RuleIndex = YQLParserRULE_id_schema return p } @@ -81377,13 +81377,13 @@ func (s *Id_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Id_schemaContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_schema(s) } } func (s *Id_schemaContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_schema(s) } } @@ -81391,9 +81391,9 @@ func (s *Id_schemaContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { +func (p *YQLParser) Id_schema() (localctx IId_schemaContext) { localctx = NewId_schemaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 784, YQLv1Antlr4ParserRULE_id_schema) + p.EnterRule(localctx, 784, YQLParserRULE_id_schema) p.SetState(4386) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -81401,7 +81401,7 @@ func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4379) @@ -81409,7 +81409,7 @@ func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4380) @@ -81417,7 +81417,7 @@ func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { } - case YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE: + case YQLParserASYMMETRIC, YQLParserBETWEEN, YQLParserBITCAST, YQLParserCASE, YQLParserCAST, YQLParserCUBE, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserEMPTY_ACTION, YQLParserEXISTS, YQLParserFROM, YQLParserFULL, YQLParserHOP, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserNOT, YQLParserNULL, YQLParserPROCESS, YQLParserREDUCE, YQLParserRETURN, YQLParserRETURNING, YQLParserROLLUP, YQLParserSELECT, YQLParserSYMMETRIC, YQLParserUNBOUNDED, YQLParserWHEN, YQLParserWHERE: p.EnterOuterAlt(localctx, 3) { p.SetState(4381) @@ -81425,7 +81425,7 @@ func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { } - case YQLv1Antlr4ParserALL, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITHOUT: + case YQLParserALL, YQLParserAS, YQLParserASSUME, YQLParserDISTINCT, YQLParserEXCEPT, YQLParserHAVING, YQLParserINTERSECT, YQLParserLIMIT, YQLParserUNION, YQLParserWINDOW, YQLParserWITHOUT: p.EnterOuterAlt(localctx, 4) { p.SetState(4382) @@ -81433,7 +81433,7 @@ func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { } - case YQLv1Antlr4ParserCOMPACT: + case YQLParserCOMPACT: p.EnterOuterAlt(localctx, 5) { p.SetState(4383) @@ -81441,7 +81441,7 @@ func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { } - case YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserROWS: + case YQLParserGROUPS, YQLParserRANGE, YQLParserROWS: p.EnterOuterAlt(localctx, 6) { p.SetState(4384) @@ -81449,7 +81449,7 @@ func (p *YQLv1Antlr4Parser) Id_schema() (localctx IId_schemaContext) { } - case YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserSCHEMA: + case YQLParserCOLUMNS, YQLParserSCHEMA: p.EnterOuterAlt(localctx, 7) { p.SetState(4385) @@ -81505,13 +81505,13 @@ type Id_exprContext struct { func NewEmptyId_exprContext() *Id_exprContext { var p = new(Id_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_expr + p.RuleIndex = YQLParserRULE_id_expr return p } func InitEmptyId_exprContext(p *Id_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_expr + p.RuleIndex = YQLParserRULE_id_expr } func (*Id_exprContext) IsId_exprContext() {} @@ -81522,7 +81522,7 @@ func NewId_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_expr + p.RuleIndex = YQLParserRULE_id_expr return p } @@ -81635,13 +81635,13 @@ func (s *Id_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *Id_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_expr(s) } } func (s *Id_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_expr(s) } } @@ -81649,9 +81649,9 @@ func (s *Id_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_expr() (localctx IId_exprContext) { +func (p *YQLParser) Id_expr() (localctx IId_exprContext) { localctx = NewId_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 786, YQLv1Antlr4ParserRULE_id_expr) + p.EnterRule(localctx, 786, YQLParserRULE_id_expr) p.SetState(4394) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -81659,7 +81659,7 @@ func (p *YQLv1Antlr4Parser) Id_expr() (localctx IId_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4388) @@ -81667,7 +81667,7 @@ func (p *YQLv1Antlr4Parser) Id_expr() (localctx IId_exprContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4389) @@ -81675,7 +81675,7 @@ func (p *YQLv1Antlr4Parser) Id_expr() (localctx IId_exprContext) { } - case YQLv1Antlr4ParserCOLUMN: + case YQLParserCOLUMN: p.EnterOuterAlt(localctx, 3) { p.SetState(4390) @@ -81683,7 +81683,7 @@ func (p *YQLv1Antlr4Parser) Id_expr() (localctx IId_exprContext) { } - case YQLv1Antlr4ParserCOMPACT: + case YQLParserCOMPACT: p.EnterOuterAlt(localctx, 4) { p.SetState(4391) @@ -81691,7 +81691,7 @@ func (p *YQLv1Antlr4Parser) Id_expr() (localctx IId_exprContext) { } - case YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserROWS: + case YQLParserGROUPS, YQLParserRANGE, YQLParserROWS: p.EnterOuterAlt(localctx, 5) { p.SetState(4392) @@ -81699,7 +81699,7 @@ func (p *YQLv1Antlr4Parser) Id_expr() (localctx IId_exprContext) { } - case YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserSCHEMA: + case YQLParserCOLUMNS, YQLParserSCHEMA: p.EnterOuterAlt(localctx, 6) { p.SetState(4393) @@ -81754,13 +81754,13 @@ type Id_expr_inContext struct { func NewEmptyId_expr_inContext() *Id_expr_inContext { var p = new(Id_expr_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_expr_in + p.RuleIndex = YQLParserRULE_id_expr_in return p } func InitEmptyId_expr_inContext(p *Id_expr_inContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_expr_in + p.RuleIndex = YQLParserRULE_id_expr_in } func (*Id_expr_inContext) IsId_expr_inContext() {} @@ -81771,7 +81771,7 @@ func NewId_expr_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_expr_in + p.RuleIndex = YQLParserRULE_id_expr_in return p } @@ -81868,13 +81868,13 @@ func (s *Id_expr_inContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Id_expr_inContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_expr_in(s) } } func (s *Id_expr_inContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_expr_in(s) } } @@ -81882,9 +81882,9 @@ func (s *Id_expr_inContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_expr_in() (localctx IId_expr_inContext) { +func (p *YQLParser) Id_expr_in() (localctx IId_expr_inContext) { localctx = NewId_expr_inContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 788, YQLv1Antlr4ParserRULE_id_expr_in) + p.EnterRule(localctx, 788, YQLParserRULE_id_expr_in) p.SetState(4401) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -81892,7 +81892,7 @@ func (p *YQLv1Antlr4Parser) Id_expr_in() (localctx IId_expr_inContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4396) @@ -81900,7 +81900,7 @@ func (p *YQLv1Antlr4Parser) Id_expr_in() (localctx IId_expr_inContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4397) @@ -81908,7 +81908,7 @@ func (p *YQLv1Antlr4Parser) Id_expr_in() (localctx IId_expr_inContext) { } - case YQLv1Antlr4ParserCOLUMN: + case YQLParserCOLUMN: p.EnterOuterAlt(localctx, 3) { p.SetState(4398) @@ -81916,7 +81916,7 @@ func (p *YQLv1Antlr4Parser) Id_expr_in() (localctx IId_expr_inContext) { } - case YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserROWS: + case YQLParserGROUPS, YQLParserRANGE, YQLParserROWS: p.EnterOuterAlt(localctx, 4) { p.SetState(4399) @@ -81924,7 +81924,7 @@ func (p *YQLv1Antlr4Parser) Id_expr_in() (localctx IId_expr_inContext) { } - case YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserSCHEMA: + case YQLParserCOLUMNS, YQLParserSCHEMA: p.EnterOuterAlt(localctx, 5) { p.SetState(4400) @@ -81982,13 +81982,13 @@ type Id_windowContext struct { func NewEmptyId_windowContext() *Id_windowContext { var p = new(Id_windowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_window + p.RuleIndex = YQLParserRULE_id_window return p } func InitEmptyId_windowContext(p *Id_windowContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_window + p.RuleIndex = YQLParserRULE_id_window } func (*Id_windowContext) IsId_windowContext() {} @@ -81999,7 +81999,7 @@ func NewId_windowContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_window + p.RuleIndex = YQLParserRULE_id_window return p } @@ -82144,13 +82144,13 @@ func (s *Id_windowContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *Id_windowContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_window(s) } } func (s *Id_windowContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_window(s) } } @@ -82158,9 +82158,9 @@ func (s *Id_windowContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { +func (p *YQLParser) Id_window() (localctx IId_windowContext) { localctx = NewId_windowContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 790, YQLv1Antlr4ParserRULE_id_window) + p.EnterRule(localctx, 790, YQLParserRULE_id_window) p.SetState(4411) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -82168,7 +82168,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4403) @@ -82176,7 +82176,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4404) @@ -82184,7 +82184,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } - case YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE: + case YQLParserASYMMETRIC, YQLParserBETWEEN, YQLParserBITCAST, YQLParserCASE, YQLParserCAST, YQLParserCUBE, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserEMPTY_ACTION, YQLParserEXISTS, YQLParserFROM, YQLParserFULL, YQLParserHOP, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserNOT, YQLParserNULL, YQLParserPROCESS, YQLParserREDUCE, YQLParserRETURN, YQLParserRETURNING, YQLParserROLLUP, YQLParserSELECT, YQLParserSYMMETRIC, YQLParserUNBOUNDED, YQLParserWHEN, YQLParserWHERE: p.EnterOuterAlt(localctx, 3) { p.SetState(4405) @@ -82192,7 +82192,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } - case YQLv1Antlr4ParserANY, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserSTREAM: + case YQLParserANY, YQLParserERASE, YQLParserSTREAM: p.EnterOuterAlt(localctx, 4) { p.SetState(4406) @@ -82200,7 +82200,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } - case YQLv1Antlr4ParserALL, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITHOUT: + case YQLParserALL, YQLParserAS, YQLParserASSUME, YQLParserDISTINCT, YQLParserEXCEPT, YQLParserHAVING, YQLParserINTERSECT, YQLParserLIMIT, YQLParserUNION, YQLParserWINDOW, YQLParserWITHOUT: p.EnterOuterAlt(localctx, 5) { p.SetState(4407) @@ -82208,7 +82208,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } - case YQLv1Antlr4ParserCOLUMN: + case YQLParserCOLUMN: p.EnterOuterAlt(localctx, 6) { p.SetState(4408) @@ -82216,7 +82216,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } - case YQLv1Antlr4ParserCOMPACT: + case YQLParserCOMPACT: p.EnterOuterAlt(localctx, 7) { p.SetState(4409) @@ -82224,7 +82224,7 @@ func (p *YQLv1Antlr4Parser) Id_window() (localctx IId_windowContext) { } - case YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserSCHEMA: + case YQLParserCOLUMNS, YQLParserSCHEMA: p.EnterOuterAlt(localctx, 8) { p.SetState(4410) @@ -82281,13 +82281,13 @@ type Id_tableContext struct { func NewEmptyId_tableContext() *Id_tableContext { var p = new(Id_tableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table + p.RuleIndex = YQLParserRULE_id_table return p } func InitEmptyId_tableContext(p *Id_tableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table + p.RuleIndex = YQLParserRULE_id_table } func (*Id_tableContext) IsId_tableContext() {} @@ -82298,7 +82298,7 @@ func NewId_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table + p.RuleIndex = YQLParserRULE_id_table return p } @@ -82427,13 +82427,13 @@ func (s *Id_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *Id_tableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_table(s) } } func (s *Id_tableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_table(s) } } @@ -82441,9 +82441,9 @@ func (s *Id_tableContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { +func (p *YQLParser) Id_table() (localctx IId_tableContext) { localctx = NewId_tableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 792, YQLv1Antlr4ParserRULE_id_table) + p.EnterRule(localctx, 792, YQLParserRULE_id_table) p.SetState(4420) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -82451,7 +82451,7 @@ func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4413) @@ -82459,7 +82459,7 @@ func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4414) @@ -82467,7 +82467,7 @@ func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { } - case YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE: + case YQLParserASYMMETRIC, YQLParserBETWEEN, YQLParserBITCAST, YQLParserCASE, YQLParserCAST, YQLParserCUBE, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserEMPTY_ACTION, YQLParserEXISTS, YQLParserFROM, YQLParserFULL, YQLParserHOP, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserNOT, YQLParserNULL, YQLParserPROCESS, YQLParserREDUCE, YQLParserRETURN, YQLParserRETURNING, YQLParserROLLUP, YQLParserSELECT, YQLParserSYMMETRIC, YQLParserUNBOUNDED, YQLParserWHEN, YQLParserWHERE: p.EnterOuterAlt(localctx, 3) { p.SetState(4415) @@ -82475,7 +82475,7 @@ func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { } - case YQLv1Antlr4ParserALL, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITHOUT: + case YQLParserALL, YQLParserAS, YQLParserASSUME, YQLParserDISTINCT, YQLParserEXCEPT, YQLParserHAVING, YQLParserINTERSECT, YQLParserLIMIT, YQLParserUNION, YQLParserWINDOW, YQLParserWITHOUT: p.EnterOuterAlt(localctx, 4) { p.SetState(4416) @@ -82483,7 +82483,7 @@ func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { } - case YQLv1Antlr4ParserCOMPACT: + case YQLParserCOMPACT: p.EnterOuterAlt(localctx, 5) { p.SetState(4417) @@ -82491,7 +82491,7 @@ func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { } - case YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserROWS: + case YQLParserGROUPS, YQLParserRANGE, YQLParserROWS: p.EnterOuterAlt(localctx, 6) { p.SetState(4418) @@ -82499,7 +82499,7 @@ func (p *YQLv1Antlr4Parser) Id_table() (localctx IId_tableContext) { } - case YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserSCHEMA: + case YQLParserCOLUMNS, YQLParserSCHEMA: p.EnterOuterAlt(localctx, 7) { p.SetState(4419) @@ -82556,13 +82556,13 @@ type Id_withoutContext struct { func NewEmptyId_withoutContext() *Id_withoutContext { var p = new(Id_withoutContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_without + p.RuleIndex = YQLParserRULE_id_without return p } func InitEmptyId_withoutContext(p *Id_withoutContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_without + p.RuleIndex = YQLParserRULE_id_without } func (*Id_withoutContext) IsId_withoutContext() {} @@ -82573,7 +82573,7 @@ func NewId_withoutContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_without + p.RuleIndex = YQLParserRULE_id_without return p } @@ -82702,13 +82702,13 @@ func (s *Id_withoutContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Id_withoutContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_without(s) } } func (s *Id_withoutContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_without(s) } } @@ -82716,9 +82716,9 @@ func (s *Id_withoutContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { +func (p *YQLParser) Id_without() (localctx IId_withoutContext) { localctx = NewId_withoutContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 794, YQLv1Antlr4ParserRULE_id_without) + p.EnterRule(localctx, 794, YQLParserRULE_id_without) p.SetState(4429) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -82726,7 +82726,7 @@ func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4422) @@ -82734,7 +82734,7 @@ func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4423) @@ -82742,7 +82742,7 @@ func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { } - case YQLv1Antlr4ParserANY, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserSTREAM: + case YQLParserANY, YQLParserERASE, YQLParserSTREAM: p.EnterOuterAlt(localctx, 3) { p.SetState(4424) @@ -82750,7 +82750,7 @@ func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { } - case YQLv1Antlr4ParserCOLUMN: + case YQLParserCOLUMN: p.EnterOuterAlt(localctx, 4) { p.SetState(4425) @@ -82758,7 +82758,7 @@ func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { } - case YQLv1Antlr4ParserCOMPACT: + case YQLParserCOMPACT: p.EnterOuterAlt(localctx, 5) { p.SetState(4426) @@ -82766,7 +82766,7 @@ func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { } - case YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserROWS: + case YQLParserGROUPS, YQLParserRANGE, YQLParserROWS: p.EnterOuterAlt(localctx, 6) { p.SetState(4427) @@ -82774,7 +82774,7 @@ func (p *YQLv1Antlr4Parser) Id_without() (localctx IId_withoutContext) { } - case YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserSCHEMA: + case YQLParserCOLUMNS, YQLParserSCHEMA: p.EnterOuterAlt(localctx, 7) { p.SetState(4428) @@ -82832,13 +82832,13 @@ type Id_hintContext struct { func NewEmptyId_hintContext() *Id_hintContext { var p = new(Id_hintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_hint + p.RuleIndex = YQLParserRULE_id_hint return p } func InitEmptyId_hintContext(p *Id_hintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_hint + p.RuleIndex = YQLParserRULE_id_hint } func (*Id_hintContext) IsId_hintContext() {} @@ -82849,7 +82849,7 @@ func NewId_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_hint + p.RuleIndex = YQLParserRULE_id_hint return p } @@ -82994,13 +82994,13 @@ func (s *Id_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *Id_hintContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_hint(s) } } func (s *Id_hintContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_hint(s) } } @@ -83008,9 +83008,9 @@ func (s *Id_hintContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { +func (p *YQLParser) Id_hint() (localctx IId_hintContext) { localctx = NewId_hintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 796, YQLv1Antlr4ParserRULE_id_hint) + p.EnterRule(localctx, 796, YQLParserRULE_id_hint) p.SetState(4439) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83018,7 +83018,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4431) @@ -83026,7 +83026,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4432) @@ -83034,7 +83034,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } - case YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE: + case YQLParserASYMMETRIC, YQLParserBETWEEN, YQLParserBITCAST, YQLParserCASE, YQLParserCAST, YQLParserCUBE, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserEMPTY_ACTION, YQLParserEXISTS, YQLParserFROM, YQLParserFULL, YQLParserHOP, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserNOT, YQLParserNULL, YQLParserPROCESS, YQLParserREDUCE, YQLParserRETURN, YQLParserRETURNING, YQLParserROLLUP, YQLParserSELECT, YQLParserSYMMETRIC, YQLParserUNBOUNDED, YQLParserWHEN, YQLParserWHERE: p.EnterOuterAlt(localctx, 3) { p.SetState(4433) @@ -83042,7 +83042,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } - case YQLv1Antlr4ParserANY, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserSTREAM: + case YQLParserANY, YQLParserERASE, YQLParserSTREAM: p.EnterOuterAlt(localctx, 4) { p.SetState(4434) @@ -83050,7 +83050,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } - case YQLv1Antlr4ParserALL, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITHOUT: + case YQLParserALL, YQLParserAS, YQLParserASSUME, YQLParserDISTINCT, YQLParserEXCEPT, YQLParserHAVING, YQLParserINTERSECT, YQLParserLIMIT, YQLParserUNION, YQLParserWINDOW, YQLParserWITHOUT: p.EnterOuterAlt(localctx, 5) { p.SetState(4435) @@ -83058,7 +83058,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } - case YQLv1Antlr4ParserCOLUMN: + case YQLParserCOLUMN: p.EnterOuterAlt(localctx, 6) { p.SetState(4436) @@ -83066,7 +83066,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } - case YQLv1Antlr4ParserCOMPACT: + case YQLParserCOMPACT: p.EnterOuterAlt(localctx, 7) { p.SetState(4437) @@ -83074,7 +83074,7 @@ func (p *YQLv1Antlr4Parser) Id_hint() (localctx IId_hintContext) { } - case YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserROWS: + case YQLParserGROUPS, YQLParserRANGE, YQLParserROWS: p.EnterOuterAlt(localctx, 8) { p.SetState(4438) @@ -83126,13 +83126,13 @@ type Id_as_compatContext struct { func NewEmptyId_as_compatContext() *Id_as_compatContext { var p = new(Id_as_compatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_as_compat + p.RuleIndex = YQLParserRULE_id_as_compat return p } func InitEmptyId_as_compatContext(p *Id_as_compatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_as_compat + p.RuleIndex = YQLParserRULE_id_as_compat } func (*Id_as_compatContext) IsId_as_compatContext() {} @@ -83143,7 +83143,7 @@ func NewId_as_compatContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_as_compat + p.RuleIndex = YQLParserRULE_id_as_compat return p } @@ -83192,13 +83192,13 @@ func (s *Id_as_compatContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Id_as_compatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_as_compat(s) } } func (s *Id_as_compatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_as_compat(s) } } @@ -83206,9 +83206,9 @@ func (s *Id_as_compatContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_as_compat() (localctx IId_as_compatContext) { +func (p *YQLParser) Id_as_compat() (localctx IId_as_compatContext) { localctx = NewId_as_compatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 798, YQLv1Antlr4ParserRULE_id_as_compat) + p.EnterRule(localctx, 798, YQLParserRULE_id_as_compat) p.SetState(4443) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83216,7 +83216,7 @@ func (p *YQLv1Antlr4Parser) Id_as_compat() (localctx IId_as_compatContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4441) @@ -83224,7 +83224,7 @@ func (p *YQLv1Antlr4Parser) Id_as_compat() (localctx IId_as_compatContext) { } - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserLAST, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserREVERT, YQLParserREVOKE, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserVACUUM, YQLParserVALUES, YQLParserVIRTUAL, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 2) { p.SetState(4442) @@ -83276,13 +83276,13 @@ type An_idContext struct { func NewEmptyAn_idContext() *An_idContext { var p = new(An_idContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id + p.RuleIndex = YQLParserRULE_an_id return p } func InitEmptyAn_idContext(p *An_idContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id + p.RuleIndex = YQLParserRULE_an_id } func (*An_idContext) IsAn_idContext() {} @@ -83293,7 +83293,7 @@ func NewAn_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invoki antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id + p.RuleIndex = YQLParserRULE_an_id return p } @@ -83317,7 +83317,7 @@ func (s *An_idContext) Id() IIdContext { } func (s *An_idContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_idContext) GetRuleContext() antlr.RuleContext { @@ -83330,13 +83330,13 @@ func (s *An_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) func (s *An_idContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id(s) } } func (s *An_idContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id(s) } } @@ -83344,9 +83344,9 @@ func (s *An_idContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id() (localctx IAn_idContext) { +func (p *YQLParser) An_id() (localctx IAn_idContext) { localctx = NewAn_idContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 800, YQLv1Antlr4ParserRULE_an_id) + p.EnterRule(localctx, 800, YQLParserRULE_an_id) p.SetState(4447) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83354,7 +83354,7 @@ func (p *YQLv1Antlr4Parser) An_id() (localctx IAn_idContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4445) @@ -83362,11 +83362,11 @@ func (p *YQLv1Antlr4Parser) An_id() (localctx IAn_idContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4446) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83418,13 +83418,13 @@ type An_id_or_typeContext struct { func NewEmptyAn_id_or_typeContext() *An_id_or_typeContext { var p = new(An_id_or_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_or_type + p.RuleIndex = YQLParserRULE_an_id_or_type return p } func InitEmptyAn_id_or_typeContext(p *An_id_or_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_or_type + p.RuleIndex = YQLParserRULE_an_id_or_type } func (*An_id_or_typeContext) IsAn_id_or_typeContext() {} @@ -83435,7 +83435,7 @@ func NewAn_id_or_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_or_type + p.RuleIndex = YQLParserRULE_an_id_or_type return p } @@ -83459,7 +83459,7 @@ func (s *An_id_or_typeContext) Id_or_type() IId_or_typeContext { } func (s *An_id_or_typeContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_or_typeContext) GetRuleContext() antlr.RuleContext { @@ -83472,13 +83472,13 @@ func (s *An_id_or_typeContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *An_id_or_typeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_or_type(s) } } func (s *An_id_or_typeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_or_type(s) } } @@ -83486,9 +83486,9 @@ func (s *An_id_or_typeContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_or_type() (localctx IAn_id_or_typeContext) { +func (p *YQLParser) An_id_or_type() (localctx IAn_id_or_typeContext) { localctx = NewAn_id_or_typeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 802, YQLv1Antlr4ParserRULE_an_id_or_type) + p.EnterRule(localctx, 802, YQLParserRULE_an_id_or_type) p.SetState(4451) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83496,7 +83496,7 @@ func (p *YQLv1Antlr4Parser) An_id_or_type() (localctx IAn_id_or_typeContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVARIANT, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCALLABLE, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDICT, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserENUM, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFLOW, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLIST, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOPTIONAL, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESOURCE, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSET, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSTRUCT, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTAGGED, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTUPLE, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVARIANT, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4449) @@ -83504,11 +83504,11 @@ func (p *YQLv1Antlr4Parser) An_id_or_type() (localctx IAn_id_or_typeContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4450) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83560,13 +83560,13 @@ type An_id_schemaContext struct { func NewEmptyAn_id_schemaContext() *An_id_schemaContext { var p = new(An_id_schemaContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_schema + p.RuleIndex = YQLParserRULE_an_id_schema return p } func InitEmptyAn_id_schemaContext(p *An_id_schemaContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_schema + p.RuleIndex = YQLParserRULE_an_id_schema } func (*An_id_schemaContext) IsAn_id_schemaContext() {} @@ -83577,7 +83577,7 @@ func NewAn_id_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_schema + p.RuleIndex = YQLParserRULE_an_id_schema return p } @@ -83601,7 +83601,7 @@ func (s *An_id_schemaContext) Id_schema() IId_schemaContext { } func (s *An_id_schemaContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_schemaContext) GetRuleContext() antlr.RuleContext { @@ -83614,13 +83614,13 @@ func (s *An_id_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *An_id_schemaContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_schema(s) } } func (s *An_id_schemaContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_schema(s) } } @@ -83628,9 +83628,9 @@ func (s *An_id_schemaContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_schema() (localctx IAn_id_schemaContext) { +func (p *YQLParser) An_id_schema() (localctx IAn_id_schemaContext) { localctx = NewAn_id_schemaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 804, YQLv1Antlr4ParserRULE_an_id_schema) + p.EnterRule(localctx, 804, YQLParserRULE_an_id_schema) p.SetState(4455) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83638,7 +83638,7 @@ func (p *YQLv1Antlr4Parser) An_id_schema() (localctx IAn_id_schemaContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4453) @@ -83646,11 +83646,11 @@ func (p *YQLv1Antlr4Parser) An_id_schema() (localctx IAn_id_schemaContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4454) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83702,13 +83702,13 @@ type An_id_exprContext struct { func NewEmptyAn_id_exprContext() *An_id_exprContext { var p = new(An_id_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_expr + p.RuleIndex = YQLParserRULE_an_id_expr return p } func InitEmptyAn_id_exprContext(p *An_id_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_expr + p.RuleIndex = YQLParserRULE_an_id_expr } func (*An_id_exprContext) IsAn_id_exprContext() {} @@ -83719,7 +83719,7 @@ func NewAn_id_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_expr + p.RuleIndex = YQLParserRULE_an_id_expr return p } @@ -83743,7 +83743,7 @@ func (s *An_id_exprContext) Id_expr() IId_exprContext { } func (s *An_id_exprContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_exprContext) GetRuleContext() antlr.RuleContext { @@ -83756,13 +83756,13 @@ func (s *An_id_exprContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *An_id_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_expr(s) } } func (s *An_id_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_expr(s) } } @@ -83770,9 +83770,9 @@ func (s *An_id_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_expr() (localctx IAn_id_exprContext) { +func (p *YQLParser) An_id_expr() (localctx IAn_id_exprContext) { localctx = NewAn_id_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 806, YQLv1Antlr4ParserRULE_an_id_expr) + p.EnterRule(localctx, 806, YQLParserRULE_an_id_expr) p.SetState(4459) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83780,7 +83780,7 @@ func (p *YQLv1Antlr4Parser) An_id_expr() (localctx IAn_id_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4457) @@ -83788,11 +83788,11 @@ func (p *YQLv1Antlr4Parser) An_id_expr() (localctx IAn_id_exprContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4458) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83844,13 +83844,13 @@ type An_id_expr_inContext struct { func NewEmptyAn_id_expr_inContext() *An_id_expr_inContext { var p = new(An_id_expr_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_expr_in + p.RuleIndex = YQLParserRULE_an_id_expr_in return p } func InitEmptyAn_id_expr_inContext(p *An_id_expr_inContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_expr_in + p.RuleIndex = YQLParserRULE_an_id_expr_in } func (*An_id_expr_inContext) IsAn_id_expr_inContext() {} @@ -83861,7 +83861,7 @@ func NewAn_id_expr_inContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_expr_in + p.RuleIndex = YQLParserRULE_an_id_expr_in return p } @@ -83885,7 +83885,7 @@ func (s *An_id_expr_inContext) Id_expr_in() IId_expr_inContext { } func (s *An_id_expr_inContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_expr_inContext) GetRuleContext() antlr.RuleContext { @@ -83898,13 +83898,13 @@ func (s *An_id_expr_inContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *An_id_expr_inContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_expr_in(s) } } func (s *An_id_expr_inContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_expr_in(s) } } @@ -83912,9 +83912,9 @@ func (s *An_id_expr_inContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_expr_in() (localctx IAn_id_expr_inContext) { +func (p *YQLParser) An_id_expr_in() (localctx IAn_id_expr_inContext) { localctx = NewAn_id_expr_inContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 808, YQLv1Antlr4ParserRULE_an_id_expr_in) + p.EnterRule(localctx, 808, YQLParserRULE_an_id_expr_in) p.SetState(4463) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83922,7 +83922,7 @@ func (p *YQLv1Antlr4Parser) An_id_expr_in() (localctx IAn_id_expr_inContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4461) @@ -83930,11 +83930,11 @@ func (p *YQLv1Antlr4Parser) An_id_expr_in() (localctx IAn_id_expr_inContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4462) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83986,13 +83986,13 @@ type An_id_windowContext struct { func NewEmptyAn_id_windowContext() *An_id_windowContext { var p = new(An_id_windowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_window + p.RuleIndex = YQLParserRULE_an_id_window return p } func InitEmptyAn_id_windowContext(p *An_id_windowContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_window + p.RuleIndex = YQLParserRULE_an_id_window } func (*An_id_windowContext) IsAn_id_windowContext() {} @@ -84003,7 +84003,7 @@ func NewAn_id_windowContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_window + p.RuleIndex = YQLParserRULE_an_id_window return p } @@ -84027,7 +84027,7 @@ func (s *An_id_windowContext) Id_window() IId_windowContext { } func (s *An_id_windowContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_windowContext) GetRuleContext() antlr.RuleContext { @@ -84040,13 +84040,13 @@ func (s *An_id_windowContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *An_id_windowContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_window(s) } } func (s *An_id_windowContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_window(s) } } @@ -84054,9 +84054,9 @@ func (s *An_id_windowContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_window() (localctx IAn_id_windowContext) { +func (p *YQLParser) An_id_window() (localctx IAn_id_windowContext) { localctx = NewAn_id_windowContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 810, YQLv1Antlr4ParserRULE_an_id_window) + p.EnterRule(localctx, 810, YQLParserRULE_an_id_window) p.SetState(4467) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84064,7 +84064,7 @@ func (p *YQLv1Antlr4Parser) An_id_window() (localctx IAn_id_windowContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4465) @@ -84072,11 +84072,11 @@ func (p *YQLv1Antlr4Parser) An_id_window() (localctx IAn_id_windowContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4466) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84128,13 +84128,13 @@ type An_id_tableContext struct { func NewEmptyAn_id_tableContext() *An_id_tableContext { var p = new(An_id_tableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_table + p.RuleIndex = YQLParserRULE_an_id_table return p } func InitEmptyAn_id_tableContext(p *An_id_tableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_table + p.RuleIndex = YQLParserRULE_an_id_table } func (*An_id_tableContext) IsAn_id_tableContext() {} @@ -84145,7 +84145,7 @@ func NewAn_id_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_table + p.RuleIndex = YQLParserRULE_an_id_table return p } @@ -84169,7 +84169,7 @@ func (s *An_id_tableContext) Id_table() IId_tableContext { } func (s *An_id_tableContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_tableContext) GetRuleContext() antlr.RuleContext { @@ -84182,13 +84182,13 @@ func (s *An_id_tableContext) ToStringTree(ruleNames []string, recog antlr.Recogn func (s *An_id_tableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_table(s) } } func (s *An_id_tableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_table(s) } } @@ -84196,9 +84196,9 @@ func (s *An_id_tableContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_table() (localctx IAn_id_tableContext) { +func (p *YQLParser) An_id_table() (localctx IAn_id_tableContext) { localctx = NewAn_id_tableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 812, YQLv1Antlr4ParserRULE_an_id_table) + p.EnterRule(localctx, 812, YQLParserRULE_an_id_table) p.SetState(4471) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84206,7 +84206,7 @@ func (p *YQLv1Antlr4Parser) An_id_table() (localctx IAn_id_tableContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4469) @@ -84214,11 +84214,11 @@ func (p *YQLv1Antlr4Parser) An_id_table() (localctx IAn_id_tableContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4470) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84270,13 +84270,13 @@ type An_id_withoutContext struct { func NewEmptyAn_id_withoutContext() *An_id_withoutContext { var p = new(An_id_withoutContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_without + p.RuleIndex = YQLParserRULE_an_id_without return p } func InitEmptyAn_id_withoutContext(p *An_id_withoutContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_without + p.RuleIndex = YQLParserRULE_an_id_without } func (*An_id_withoutContext) IsAn_id_withoutContext() {} @@ -84287,7 +84287,7 @@ func NewAn_id_withoutContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_without + p.RuleIndex = YQLParserRULE_an_id_without return p } @@ -84311,7 +84311,7 @@ func (s *An_id_withoutContext) Id_without() IId_withoutContext { } func (s *An_id_withoutContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_withoutContext) GetRuleContext() antlr.RuleContext { @@ -84324,13 +84324,13 @@ func (s *An_id_withoutContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *An_id_withoutContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_without(s) } } func (s *An_id_withoutContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_without(s) } } @@ -84338,9 +84338,9 @@ func (s *An_id_withoutContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_without() (localctx IAn_id_withoutContext) { +func (p *YQLParser) An_id_without() (localctx IAn_id_withoutContext) { localctx = NewAn_id_withoutContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 814, YQLv1Antlr4ParserRULE_an_id_without) + p.EnterRule(localctx, 814, YQLParserRULE_an_id_without) p.SetState(4475) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84348,7 +84348,7 @@ func (p *YQLv1Antlr4Parser) An_id_without() (localctx IAn_id_withoutContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4473) @@ -84356,11 +84356,11 @@ func (p *YQLv1Antlr4Parser) An_id_without() (localctx IAn_id_withoutContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4474) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84412,13 +84412,13 @@ type An_id_hintContext struct { func NewEmptyAn_id_hintContext() *An_id_hintContext { var p = new(An_id_hintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_hint + p.RuleIndex = YQLParserRULE_an_id_hint return p } func InitEmptyAn_id_hintContext(p *An_id_hintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_hint + p.RuleIndex = YQLParserRULE_an_id_hint } func (*An_id_hintContext) IsAn_id_hintContext() {} @@ -84429,7 +84429,7 @@ func NewAn_id_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_hint + p.RuleIndex = YQLParserRULE_an_id_hint return p } @@ -84453,7 +84453,7 @@ func (s *An_id_hintContext) Id_hint() IId_hintContext { } func (s *An_id_hintContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_hintContext) GetRuleContext() antlr.RuleContext { @@ -84466,13 +84466,13 @@ func (s *An_id_hintContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *An_id_hintContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_hint(s) } } func (s *An_id_hintContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_hint(s) } } @@ -84480,9 +84480,9 @@ func (s *An_id_hintContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_hint() (localctx IAn_id_hintContext) { +func (p *YQLParser) An_id_hint() (localctx IAn_id_hintContext) { localctx = NewAn_id_hintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 816, YQLv1Antlr4ParserRULE_an_id_hint) + p.EnterRule(localctx, 816, YQLParserRULE_an_id_hint) p.SetState(4479) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84490,7 +84490,7 @@ func (p *YQLv1Antlr4Parser) An_id_hint() (localctx IAn_id_hintContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4477) @@ -84498,11 +84498,11 @@ func (p *YQLv1Antlr4Parser) An_id_hint() (localctx IAn_id_hintContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4478) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84554,13 +84554,13 @@ type An_id_pureContext struct { func NewEmptyAn_id_pureContext() *An_id_pureContext { var p = new(An_id_pureContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_pure + p.RuleIndex = YQLParserRULE_an_id_pure return p } func InitEmptyAn_id_pureContext(p *An_id_pureContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_pure + p.RuleIndex = YQLParserRULE_an_id_pure } func (*An_id_pureContext) IsAn_id_pureContext() {} @@ -84571,7 +84571,7 @@ func NewAn_id_pureContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_pure + p.RuleIndex = YQLParserRULE_an_id_pure return p } @@ -84595,7 +84595,7 @@ func (s *An_id_pureContext) Identifier() IIdentifierContext { } func (s *An_id_pureContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_pureContext) GetRuleContext() antlr.RuleContext { @@ -84608,13 +84608,13 @@ func (s *An_id_pureContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *An_id_pureContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_pure(s) } } func (s *An_id_pureContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_pure(s) } } @@ -84622,9 +84622,9 @@ func (s *An_id_pureContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_pure() (localctx IAn_id_pureContext) { +func (p *YQLParser) An_id_pure() (localctx IAn_id_pureContext) { localctx = NewAn_id_pureContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 818, YQLv1Antlr4ParserRULE_an_id_pure) + p.EnterRule(localctx, 818, YQLParserRULE_an_id_pure) p.SetState(4483) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84632,7 +84632,7 @@ func (p *YQLv1Antlr4Parser) An_id_pure() (localctx IAn_id_pureContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4481) @@ -84640,11 +84640,11 @@ func (p *YQLv1Antlr4Parser) An_id_pure() (localctx IAn_id_pureContext) { } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4482) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84696,13 +84696,13 @@ type An_id_as_compatContext struct { func NewEmptyAn_id_as_compatContext() *An_id_as_compatContext { var p = new(An_id_as_compatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_as_compat + p.RuleIndex = YQLParserRULE_an_id_as_compat return p } func InitEmptyAn_id_as_compatContext(p *An_id_as_compatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_as_compat + p.RuleIndex = YQLParserRULE_an_id_as_compat } func (*An_id_as_compatContext) IsAn_id_as_compatContext() {} @@ -84713,7 +84713,7 @@ func NewAn_id_as_compatContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_an_id_as_compat + p.RuleIndex = YQLParserRULE_an_id_as_compat return p } @@ -84737,7 +84737,7 @@ func (s *An_id_as_compatContext) Id_as_compat() IId_as_compatContext { } func (s *An_id_as_compatContext) STRING_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRING_VALUE, 0) + return s.GetToken(YQLParserSTRING_VALUE, 0) } func (s *An_id_as_compatContext) GetRuleContext() antlr.RuleContext { @@ -84750,13 +84750,13 @@ func (s *An_id_as_compatContext) ToStringTree(ruleNames []string, recog antlr.Re func (s *An_id_as_compatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterAn_id_as_compat(s) } } func (s *An_id_as_compatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitAn_id_as_compat(s) } } @@ -84764,9 +84764,9 @@ func (s *An_id_as_compatContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) An_id_as_compat() (localctx IAn_id_as_compatContext) { +func (p *YQLParser) An_id_as_compat() (localctx IAn_id_as_compatContext) { localctx = NewAn_id_as_compatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 820, YQLv1Antlr4ParserRULE_an_id_as_compat) + p.EnterRule(localctx, 820, YQLParserRULE_an_id_as_compat) p.SetState(4487) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84774,7 +84774,7 @@ func (p *YQLv1Antlr4Parser) An_id_as_compat() (localctx IAn_id_as_compatContext) } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserLAST, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserREVERT, YQLParserREVOKE, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserVACUUM, YQLParserVALUES, YQLParserVIRTUAL, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4485) @@ -84782,11 +84782,11 @@ func (p *YQLv1Antlr4Parser) An_id_as_compat() (localctx IAn_id_as_compatContext) } - case YQLv1Antlr4ParserSTRING_VALUE: + case YQLParserSTRING_VALUE: p.EnterOuterAlt(localctx, 2) { p.SetState(4486) - p.Match(YQLv1Antlr4ParserSTRING_VALUE) + p.Match(YQLParserSTRING_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84839,13 +84839,13 @@ type View_nameContext struct { func NewEmptyView_nameContext() *View_nameContext { var p = new(View_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_view_name + p.RuleIndex = YQLParserRULE_view_name return p } func InitEmptyView_nameContext(p *View_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_view_name + p.RuleIndex = YQLParserRULE_view_name } func (*View_nameContext) IsView_nameContext() {} @@ -84856,7 +84856,7 @@ func NewView_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_view_name + p.RuleIndex = YQLParserRULE_view_name return p } @@ -84880,11 +84880,11 @@ func (s *View_nameContext) An_id() IAn_idContext { } func (s *View_nameContext) PRIMARY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRIMARY, 0) + return s.GetToken(YQLParserPRIMARY, 0) } func (s *View_nameContext) KEY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserKEY, 0) + return s.GetToken(YQLParserKEY, 0) } func (s *View_nameContext) GetRuleContext() antlr.RuleContext { @@ -84897,13 +84897,13 @@ func (s *View_nameContext) ToStringTree(ruleNames []string, recog antlr.Recogniz func (s *View_nameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterView_name(s) } } func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitView_name(s) } } @@ -84911,9 +84911,9 @@ func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) View_name() (localctx IView_nameContext) { +func (p *YQLParser) View_name() (localctx IView_nameContext) { localctx = NewView_nameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 822, YQLv1Antlr4ParserRULE_view_name) + p.EnterRule(localctx, 822, YQLParserRULE_view_name) p.SetState(4492) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84933,7 +84933,7 @@ func (p *YQLv1Antlr4Parser) View_name() (localctx IView_nameContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(4490) - p.Match(YQLv1Antlr4ParserPRIMARY) + p.Match(YQLParserPRIMARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84941,7 +84941,7 @@ func (p *YQLv1Antlr4Parser) View_name() (localctx IView_nameContext) { } { p.SetState(4491) - p.Match(YQLv1Antlr4ParserKEY) + p.Match(YQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84990,13 +84990,13 @@ type Opt_id_prefixContext struct { func NewEmptyOpt_id_prefixContext() *Opt_id_prefixContext { var p = new(Opt_id_prefixContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_id_prefix + p.RuleIndex = YQLParserRULE_opt_id_prefix return p } func InitEmptyOpt_id_prefixContext(p *Opt_id_prefixContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_id_prefix + p.RuleIndex = YQLParserRULE_opt_id_prefix } func (*Opt_id_prefixContext) IsOpt_id_prefixContext() {} @@ -85007,7 +85007,7 @@ func NewOpt_id_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_id_prefix + p.RuleIndex = YQLParserRULE_opt_id_prefix return p } @@ -85031,7 +85031,7 @@ func (s *Opt_id_prefixContext) An_id() IAn_idContext { } func (s *Opt_id_prefixContext) DOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, 0) + return s.GetToken(YQLParserDOT, 0) } func (s *Opt_id_prefixContext) GetRuleContext() antlr.RuleContext { @@ -85044,13 +85044,13 @@ func (s *Opt_id_prefixContext) ToStringTree(ruleNames []string, recog antlr.Reco func (s *Opt_id_prefixContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOpt_id_prefix(s) } } func (s *Opt_id_prefixContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOpt_id_prefix(s) } } @@ -85058,9 +85058,9 @@ func (s *Opt_id_prefixContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Opt_id_prefix() (localctx IOpt_id_prefixContext) { +func (p *YQLParser) Opt_id_prefix() (localctx IOpt_id_prefixContext) { localctx = NewOpt_id_prefixContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 824, YQLv1Antlr4ParserRULE_opt_id_prefix) + p.EnterRule(localctx, 824, YQLParserRULE_opt_id_prefix) p.EnterOuterAlt(localctx, 1) p.SetState(4497) p.GetErrorHandler().Sync(p) @@ -85073,7 +85073,7 @@ func (p *YQLv1Antlr4Parser) Opt_id_prefix() (localctx IOpt_id_prefixContext) { } { p.SetState(4495) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85125,13 +85125,13 @@ type Cluster_exprContext struct { func NewEmptyCluster_exprContext() *Cluster_exprContext { var p = new(Cluster_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cluster_expr + p.RuleIndex = YQLParserRULE_cluster_expr return p } func InitEmptyCluster_exprContext(p *Cluster_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_cluster_expr + p.RuleIndex = YQLParserRULE_cluster_expr } func (*Cluster_exprContext) IsCluster_exprContext() {} @@ -85142,7 +85142,7 @@ func NewCluster_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_cluster_expr + p.RuleIndex = YQLParserRULE_cluster_expr return p } @@ -85166,7 +85166,7 @@ func (s *Cluster_exprContext) Pure_column_or_named() IPure_column_or_namedContex } func (s *Cluster_exprContext) ASTERISK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASTERISK, 0) + return s.GetToken(YQLParserASTERISK, 0) } func (s *Cluster_exprContext) An_id() IAn_idContext { @@ -85186,7 +85186,7 @@ func (s *Cluster_exprContext) An_id() IAn_idContext { } func (s *Cluster_exprContext) COLON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLON, 0) + return s.GetToken(YQLParserCOLON, 0) } func (s *Cluster_exprContext) GetRuleContext() antlr.RuleContext { @@ -85199,13 +85199,13 @@ func (s *Cluster_exprContext) ToStringTree(ruleNames []string, recog antlr.Recog func (s *Cluster_exprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterCluster_expr(s) } } func (s *Cluster_exprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitCluster_expr(s) } } @@ -85213,9 +85213,9 @@ func (s *Cluster_exprContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Cluster_expr() (localctx ICluster_exprContext) { +func (p *YQLParser) Cluster_expr() (localctx ICluster_exprContext) { localctx = NewCluster_exprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 826, YQLv1Antlr4ParserRULE_cluster_expr) + p.EnterRule(localctx, 826, YQLParserRULE_cluster_expr) p.EnterOuterAlt(localctx, 1) p.SetState(4502) p.GetErrorHandler().Sync(p) @@ -85228,7 +85228,7 @@ func (p *YQLv1Antlr4Parser) Cluster_expr() (localctx ICluster_exprContext) { } { p.SetState(4500) - p.Match(YQLv1Antlr4ParserCOLON) + p.Match(YQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85245,17 +85245,17 @@ func (p *YQLv1Antlr4Parser) Cluster_expr() (localctx ICluster_exprContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserDOLLAR, YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserDOLLAR, YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: { p.SetState(4504) p.Pure_column_or_named() } - case YQLv1Antlr4ParserASTERISK: + case YQLParserASTERISK: { p.SetState(4505) - p.Match(YQLv1Antlr4ParserASTERISK) + p.Match(YQLParserASTERISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85308,13 +85308,13 @@ type Id_or_typeContext struct { func NewEmptyId_or_typeContext() *Id_or_typeContext { var p = new(Id_or_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_or_type + p.RuleIndex = YQLParserRULE_id_or_type return p } func InitEmptyId_or_typeContext(p *Id_or_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_or_type + p.RuleIndex = YQLParserRULE_id_or_type } func (*Id_or_typeContext) IsId_or_typeContext() {} @@ -85325,7 +85325,7 @@ func NewId_or_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_or_type + p.RuleIndex = YQLParserRULE_id_or_type return p } @@ -85374,13 +85374,13 @@ func (s *Id_or_typeContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Id_or_typeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_or_type(s) } } func (s *Id_or_typeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_or_type(s) } } @@ -85388,9 +85388,9 @@ func (s *Id_or_typeContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_or_type() (localctx IId_or_typeContext) { +func (p *YQLParser) Id_or_type() (localctx IId_or_typeContext) { localctx = NewId_or_typeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 828, YQLv1Antlr4ParserRULE_id_or_type) + p.EnterRule(localctx, 828, YQLParserRULE_id_or_type) p.SetState(4510) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -85398,7 +85398,7 @@ func (p *YQLv1Antlr4Parser) Id_or_type() (localctx IId_or_typeContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserANY, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMN, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSTREAM, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserANY, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMN, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERASE, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSTREAM, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4508) @@ -85406,7 +85406,7 @@ func (p *YQLv1Antlr4Parser) Id_or_type() (localctx IId_or_typeContext) { } - case YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserVARIANT: + case YQLParserCALLABLE, YQLParserDICT, YQLParserENUM, YQLParserFLOW, YQLParserLIST, YQLParserOPTIONAL, YQLParserRESOURCE, YQLParserSET, YQLParserSTRUCT, YQLParserTAGGED, YQLParserTUPLE, YQLParserVARIANT: p.EnterOuterAlt(localctx, 2) { p.SetState(4509) @@ -85458,13 +85458,13 @@ type Opt_id_prefix_or_typeContext struct { func NewEmptyOpt_id_prefix_or_typeContext() *Opt_id_prefix_or_typeContext { var p = new(Opt_id_prefix_or_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_id_prefix_or_type + p.RuleIndex = YQLParserRULE_opt_id_prefix_or_type return p } func InitEmptyOpt_id_prefix_or_typeContext(p *Opt_id_prefix_or_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_id_prefix_or_type + p.RuleIndex = YQLParserRULE_opt_id_prefix_or_type } func (*Opt_id_prefix_or_typeContext) IsOpt_id_prefix_or_typeContext() {} @@ -85475,7 +85475,7 @@ func NewOpt_id_prefix_or_typeContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_opt_id_prefix_or_type + p.RuleIndex = YQLParserRULE_opt_id_prefix_or_type return p } @@ -85499,7 +85499,7 @@ func (s *Opt_id_prefix_or_typeContext) An_id_or_type() IAn_id_or_typeContext { } func (s *Opt_id_prefix_or_typeContext) DOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDOT, 0) + return s.GetToken(YQLParserDOT, 0) } func (s *Opt_id_prefix_or_typeContext) GetRuleContext() antlr.RuleContext { @@ -85512,13 +85512,13 @@ func (s *Opt_id_prefix_or_typeContext) ToStringTree(ruleNames []string, recog an func (s *Opt_id_prefix_or_typeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterOpt_id_prefix_or_type(s) } } func (s *Opt_id_prefix_or_typeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitOpt_id_prefix_or_type(s) } } @@ -85526,9 +85526,9 @@ func (s *Opt_id_prefix_or_typeContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Opt_id_prefix_or_type() (localctx IOpt_id_prefix_or_typeContext) { +func (p *YQLParser) Opt_id_prefix_or_type() (localctx IOpt_id_prefix_or_typeContext) { localctx = NewOpt_id_prefix_or_typeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 830, YQLv1Antlr4ParserRULE_opt_id_prefix_or_type) + p.EnterRule(localctx, 830, YQLParserRULE_opt_id_prefix_or_type) p.EnterOuterAlt(localctx, 1) p.SetState(4515) p.GetErrorHandler().Sync(p) @@ -85541,7 +85541,7 @@ func (p *YQLv1Antlr4Parser) Opt_id_prefix_or_type() (localctx IOpt_id_prefix_or_ } { p.SetState(4513) - p.Match(YQLv1Antlr4ParserDOT) + p.Match(YQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85591,13 +85591,13 @@ type Id_or_atContext struct { func NewEmptyId_or_atContext() *Id_or_atContext { var p = new(Id_or_atContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_or_at + p.RuleIndex = YQLParserRULE_id_or_at return p } func InitEmptyId_or_atContext(p *Id_or_atContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_or_at + p.RuleIndex = YQLParserRULE_id_or_at } func (*Id_or_atContext) IsId_or_atContext() {} @@ -85608,7 +85608,7 @@ func NewId_or_atContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_or_at + p.RuleIndex = YQLParserRULE_id_or_at return p } @@ -85632,7 +85632,7 @@ func (s *Id_or_atContext) An_id_or_type() IAn_id_or_typeContext { } func (s *Id_or_atContext) COMMAT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMAT, 0) + return s.GetToken(YQLParserCOMMAT, 0) } func (s *Id_or_atContext) GetRuleContext() antlr.RuleContext { @@ -85645,13 +85645,13 @@ func (s *Id_or_atContext) ToStringTree(ruleNames []string, recog antlr.Recognize func (s *Id_or_atContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_or_at(s) } } func (s *Id_or_atContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_or_at(s) } } @@ -85659,9 +85659,9 @@ func (s *Id_or_atContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_or_at() (localctx IId_or_atContext) { +func (p *YQLParser) Id_or_at() (localctx IId_or_atContext) { localctx = NewId_or_atContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 832, YQLv1Antlr4ParserRULE_id_or_at) + p.EnterRule(localctx, 832, YQLParserRULE_id_or_at) var _la int p.EnterOuterAlt(localctx, 1) @@ -85673,10 +85673,10 @@ func (p *YQLv1Antlr4Parser) Id_or_at() (localctx IId_or_atContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMAT { + if _la == YQLParserCOMMAT { { p.SetState(4517) - p.Match(YQLv1Antlr4ParserCOMMAT) + p.Match(YQLParserCOMMAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85728,13 +85728,13 @@ type Id_table_or_typeContext struct { func NewEmptyId_table_or_typeContext() *Id_table_or_typeContext { var p = new(Id_table_or_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table_or_type + p.RuleIndex = YQLParserRULE_id_table_or_type return p } func InitEmptyId_table_or_typeContext(p *Id_table_or_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table_or_type + p.RuleIndex = YQLParserRULE_id_table_or_type } func (*Id_table_or_typeContext) IsId_table_or_typeContext() {} @@ -85745,7 +85745,7 @@ func NewId_table_or_typeContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table_or_type + p.RuleIndex = YQLParserRULE_id_table_or_type return p } @@ -85794,13 +85794,13 @@ func (s *Id_table_or_typeContext) ToStringTree(ruleNames []string, recog antlr.R func (s *Id_table_or_typeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_table_or_type(s) } } func (s *Id_table_or_typeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_table_or_type(s) } } @@ -85808,9 +85808,9 @@ func (s *Id_table_or_typeContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_table_or_type() (localctx IId_table_or_typeContext) { +func (p *YQLParser) Id_table_or_type() (localctx IId_table_or_typeContext) { localctx = NewId_table_or_typeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 834, YQLv1Antlr4ParserRULE_id_table_or_type) + p.EnterRule(localctx, 834, YQLParserRULE_id_table_or_type) p.SetState(4524) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -85818,7 +85818,7 @@ func (p *YQLv1Antlr4Parser) Id_table_or_type() (localctx IId_table_or_typeContex } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALL, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCOMPACT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserROWS, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSCHEMA, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWITHOUT, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR, YQLv1Antlr4ParserSTRING_VALUE, YQLv1Antlr4ParserID_PLAIN, YQLv1Antlr4ParserID_QUOTED: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALL, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserAS, YQLParserASC, YQLParserASSUME, YQLParserASYMMETRIC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBETWEEN, YQLParserBITCAST, YQLParserBY, YQLParserCASCADE, YQLParserCASE, YQLParserCAST, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOLUMNS, YQLParserCOMMIT, YQLParserCOMPACT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCUBE, YQLParserCURRENT, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDISTINCT, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserEMPTY_ACTION, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCEPT, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXISTS, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFROM, YQLParserFULL, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserGROUPS, YQLParserHASH, YQLParserHAVING, YQLParserHOP, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTERSECT, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLIMIT, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOT, YQLParserNOTNULL, YQLParserNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserPROCESS, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserRANGE, YQLParserREDUCE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserRETURN, YQLParserRETURNING, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROLLUP, YQLParserROW, YQLParserROWS, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSCHEMA, YQLParserSECONDS, YQLParserSEEK, YQLParserSELECT, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYMMETRIC, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNBOUNDED, YQLParserUNCONDITIONAL, YQLParserUNION, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWHEN, YQLParserWHERE, YQLParserWINDOW, YQLParserWITH, YQLParserWITHOUT, YQLParserWRAPPER, YQLParserXOR, YQLParserSTRING_VALUE, YQLParserID_PLAIN, YQLParserID_QUOTED: p.EnterOuterAlt(localctx, 1) { p.SetState(4522) @@ -85826,7 +85826,7 @@ func (p *YQLv1Antlr4Parser) Id_table_or_type() (localctx IId_table_or_typeContex } - case YQLv1Antlr4ParserCALLABLE, YQLv1Antlr4ParserDICT, YQLv1Antlr4ParserENUM, YQLv1Antlr4ParserFLOW, YQLv1Antlr4ParserLIST, YQLv1Antlr4ParserOPTIONAL, YQLv1Antlr4ParserRESOURCE, YQLv1Antlr4ParserSET, YQLv1Antlr4ParserSTRUCT, YQLv1Antlr4ParserTAGGED, YQLv1Antlr4ParserTUPLE, YQLv1Antlr4ParserVARIANT: + case YQLParserCALLABLE, YQLParserDICT, YQLParserENUM, YQLParserFLOW, YQLParserLIST, YQLParserOPTIONAL, YQLParserRESOURCE, YQLParserSET, YQLParserSTRUCT, YQLParserTAGGED, YQLParserTUPLE, YQLParserVARIANT: p.EnterOuterAlt(localctx, 2) { p.SetState(4523) @@ -85878,13 +85878,13 @@ type Id_table_or_atContext struct { func NewEmptyId_table_or_atContext() *Id_table_or_atContext { var p = new(Id_table_or_atContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table_or_at + p.RuleIndex = YQLParserRULE_id_table_or_at return p } func InitEmptyId_table_or_atContext(p *Id_table_or_atContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table_or_at + p.RuleIndex = YQLParserRULE_id_table_or_at } func (*Id_table_or_atContext) IsId_table_or_atContext() {} @@ -85895,7 +85895,7 @@ func NewId_table_or_atContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_id_table_or_at + p.RuleIndex = YQLParserRULE_id_table_or_at return p } @@ -85919,7 +85919,7 @@ func (s *Id_table_or_atContext) Id_table_or_type() IId_table_or_typeContext { } func (s *Id_table_or_atContext) COMMAT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMAT, 0) + return s.GetToken(YQLParserCOMMAT, 0) } func (s *Id_table_or_atContext) GetRuleContext() antlr.RuleContext { @@ -85932,13 +85932,13 @@ func (s *Id_table_or_atContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Id_table_or_atContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterId_table_or_at(s) } } func (s *Id_table_or_atContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitId_table_or_at(s) } } @@ -85946,9 +85946,9 @@ func (s *Id_table_or_atContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Id_table_or_at() (localctx IId_table_or_atContext) { +func (p *YQLParser) Id_table_or_at() (localctx IId_table_or_atContext) { localctx = NewId_table_or_atContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 836, YQLv1Antlr4ParserRULE_id_table_or_at) + p.EnterRule(localctx, 836, YQLParserRULE_id_table_or_at) var _la int p.EnterOuterAlt(localctx, 1) @@ -85960,10 +85960,10 @@ func (p *YQLv1Antlr4Parser) Id_table_or_at() (localctx IId_table_or_atContext) { _la = p.GetTokenStream().LA(1) - if _la == YQLv1Antlr4ParserCOMMAT { + if _la == YQLParserCOMMAT { { p.SetState(4526) - p.Match(YQLv1Antlr4ParserCOMMAT) + p.Match(YQLParserCOMMAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86021,13 +86021,13 @@ type KeywordContext struct { func NewEmptyKeywordContext() *KeywordContext { var p = new(KeywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword + p.RuleIndex = YQLParserRULE_keyword return p } func InitEmptyKeywordContext(p *KeywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword + p.RuleIndex = YQLParserRULE_keyword } func (*KeywordContext) IsKeywordContext() {} @@ -86038,7 +86038,7 @@ func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword + p.RuleIndex = YQLParserRULE_keyword return p } @@ -86183,13 +86183,13 @@ func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword(s) } } func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword(s) } } @@ -86197,9 +86197,9 @@ func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { +func (p *YQLParser) Keyword() (localctx IKeywordContext) { localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 838, YQLv1Antlr4ParserRULE_keyword) + p.EnterRule(localctx, 838, YQLParserRULE_keyword) p.SetState(4539) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -86207,7 +86207,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } switch p.GetTokenStream().LA(1) { - case YQLv1Antlr4ParserABORT, YQLv1Antlr4ParserACTION, YQLv1Antlr4ParserADD, YQLv1Antlr4ParserAFTER, YQLv1Antlr4ParserALTER, YQLv1Antlr4ParserANALYZE, YQLv1Antlr4ParserAND, YQLv1Antlr4ParserANSI, YQLv1Antlr4ParserARRAY, YQLv1Antlr4ParserASC, YQLv1Antlr4ParserASYNC, YQLv1Antlr4ParserAT, YQLv1Antlr4ParserATTACH, YQLv1Antlr4ParserATTRIBUTES, YQLv1Antlr4ParserAUTOINCREMENT, YQLv1Antlr4ParserBACKUP, YQLv1Antlr4ParserCOLLECTION, YQLv1Antlr4ParserBEFORE, YQLv1Antlr4ParserBEGIN, YQLv1Antlr4ParserBERNOULLI, YQLv1Antlr4ParserBY, YQLv1Antlr4ParserCASCADE, YQLv1Antlr4ParserCHANGEFEED, YQLv1Antlr4ParserCHECK, YQLv1Antlr4ParserCLASSIFIER, YQLv1Antlr4ParserCOLLATE, YQLv1Antlr4ParserCOMMIT, YQLv1Antlr4ParserCONDITIONAL, YQLv1Antlr4ParserCONFLICT, YQLv1Antlr4ParserCONNECT, YQLv1Antlr4ParserCONSTRAINT, YQLv1Antlr4ParserCONSUMER, YQLv1Antlr4ParserCOVER, YQLv1Antlr4ParserCREATE, YQLv1Antlr4ParserCROSS, YQLv1Antlr4ParserCURRENT, YQLv1Antlr4ParserDATA, YQLv1Antlr4ParserDATABASE, YQLv1Antlr4ParserDECIMAL, YQLv1Antlr4ParserDECLARE, YQLv1Antlr4ParserDEFAULT, YQLv1Antlr4ParserDEFERRABLE, YQLv1Antlr4ParserDEFERRED, YQLv1Antlr4ParserDEFINE, YQLv1Antlr4ParserDELETE, YQLv1Antlr4ParserDESC, YQLv1Antlr4ParserDESCRIBE, YQLv1Antlr4ParserDETACH, YQLv1Antlr4ParserDIRECTORY, YQLv1Antlr4ParserDISABLE, YQLv1Antlr4ParserDISCARD, YQLv1Antlr4ParserDO, YQLv1Antlr4ParserDROP, YQLv1Antlr4ParserEACH, YQLv1Antlr4ParserELSE, YQLv1Antlr4ParserEMPTY, YQLv1Antlr4ParserENCRYPTED, YQLv1Antlr4ParserEND, YQLv1Antlr4ParserERROR, YQLv1Antlr4ParserESCAPE, YQLv1Antlr4ParserEVALUATE, YQLv1Antlr4ParserEXCLUDE, YQLv1Antlr4ParserEXCLUSION, YQLv1Antlr4ParserEXCLUSIVE, YQLv1Antlr4ParserEXPLAIN, YQLv1Antlr4ParserEXPORT, YQLv1Antlr4ParserEXTERNAL, YQLv1Antlr4ParserFAIL, YQLv1Antlr4ParserFAMILY, YQLv1Antlr4ParserFILTER, YQLv1Antlr4ParserFIRST, YQLv1Antlr4ParserFLATTEN, YQLv1Antlr4ParserFOLLOWING, YQLv1Antlr4ParserFOR, YQLv1Antlr4ParserFOREIGN, YQLv1Antlr4ParserFUNCTION, YQLv1Antlr4ParserGLOB, YQLv1Antlr4ParserGLOBAL, YQLv1Antlr4ParserGRANT, YQLv1Antlr4ParserGROUP, YQLv1Antlr4ParserGROUPING, YQLv1Antlr4ParserHASH, YQLv1Antlr4ParserIF, YQLv1Antlr4ParserIGNORE, YQLv1Antlr4ParserILIKE, YQLv1Antlr4ParserIMMEDIATE, YQLv1Antlr4ParserIMPORT, YQLv1Antlr4ParserIN, YQLv1Antlr4ParserINCREMENT, YQLv1Antlr4ParserINCREMENTAL, YQLv1Antlr4ParserINDEX, YQLv1Antlr4ParserINDEXED, YQLv1Antlr4ParserINHERITS, YQLv1Antlr4ParserINITIAL, YQLv1Antlr4ParserINITIALLY, YQLv1Antlr4ParserINNER, YQLv1Antlr4ParserINSERT, YQLv1Antlr4ParserINSTEAD, YQLv1Antlr4ParserINTO, YQLv1Antlr4ParserIS, YQLv1Antlr4ParserISNULL, YQLv1Antlr4ParserJOIN, YQLv1Antlr4ParserKEY, YQLv1Antlr4ParserLAST, YQLv1Antlr4ParserLEFT, YQLv1Antlr4ParserLEGACY, YQLv1Antlr4ParserLIKE, YQLv1Antlr4ParserLOCAL, YQLv1Antlr4ParserLOGIN, YQLv1Antlr4ParserMANAGE, YQLv1Antlr4ParserMATCH, YQLv1Antlr4ParserMATCHES, YQLv1Antlr4ParserMATCH_RECOGNIZE, YQLv1Antlr4ParserMEASURES, YQLv1Antlr4ParserMICROSECONDS, YQLv1Antlr4ParserMILLISECONDS, YQLv1Antlr4ParserMODIFY, YQLv1Antlr4ParserNANOSECONDS, YQLv1Antlr4ParserNATURAL, YQLv1Antlr4ParserNEXT, YQLv1Antlr4ParserNO, YQLv1Antlr4ParserNOLOGIN, YQLv1Antlr4ParserNOTNULL, YQLv1Antlr4ParserNULLS, YQLv1Antlr4ParserOBJECT, YQLv1Antlr4ParserOF, YQLv1Antlr4ParserOFFSET, YQLv1Antlr4ParserOMIT, YQLv1Antlr4ParserON, YQLv1Antlr4ParserONE, YQLv1Antlr4ParserONLY, YQLv1Antlr4ParserOPTION, YQLv1Antlr4ParserOR, YQLv1Antlr4ParserORDER, YQLv1Antlr4ParserOTHERS, YQLv1Antlr4ParserOUTER, YQLv1Antlr4ParserOVER, YQLv1Antlr4ParserPARALLEL, YQLv1Antlr4ParserPARTITION, YQLv1Antlr4ParserPASSING, YQLv1Antlr4ParserPASSWORD, YQLv1Antlr4ParserPAST, YQLv1Antlr4ParserPATTERN, YQLv1Antlr4ParserPER, YQLv1Antlr4ParserPERMUTE, YQLv1Antlr4ParserPLAN, YQLv1Antlr4ParserPOOL, YQLv1Antlr4ParserPRAGMA, YQLv1Antlr4ParserPRECEDING, YQLv1Antlr4ParserPRESORT, YQLv1Antlr4ParserPRIMARY, YQLv1Antlr4ParserPRIVILEGES, YQLv1Antlr4ParserQUERY, YQLv1Antlr4ParserQUEUE, YQLv1Antlr4ParserRAISE, YQLv1Antlr4ParserREFERENCES, YQLv1Antlr4ParserREGEXP, YQLv1Antlr4ParserREINDEX, YQLv1Antlr4ParserRELEASE, YQLv1Antlr4ParserREMOVE, YQLv1Antlr4ParserRENAME, YQLv1Antlr4ParserREPLACE, YQLv1Antlr4ParserREPLICATION, YQLv1Antlr4ParserRESET, YQLv1Antlr4ParserRESPECT, YQLv1Antlr4ParserRESTART, YQLv1Antlr4ParserRESTORE, YQLv1Antlr4ParserRESTRICT, YQLv1Antlr4ParserRESULT, YQLv1Antlr4ParserREVERT, YQLv1Antlr4ParserREVOKE, YQLv1Antlr4ParserRIGHT, YQLv1Antlr4ParserRLIKE, YQLv1Antlr4ParserROLLBACK, YQLv1Antlr4ParserROW, YQLv1Antlr4ParserSAMPLE, YQLv1Antlr4ParserSAVEPOINT, YQLv1Antlr4ParserSECONDS, YQLv1Antlr4ParserSEEK, YQLv1Antlr4ParserSEMI, YQLv1Antlr4ParserSETS, YQLv1Antlr4ParserSHOW, YQLv1Antlr4ParserTSKIP, YQLv1Antlr4ParserSEQUENCE, YQLv1Antlr4ParserSOURCE, YQLv1Antlr4ParserSTART, YQLv1Antlr4ParserSUBQUERY, YQLv1Antlr4ParserSUBSET, YQLv1Antlr4ParserSYMBOLS, YQLv1Antlr4ParserSYNC, YQLv1Antlr4ParserSYSTEM, YQLv1Antlr4ParserTABLE, YQLv1Antlr4ParserTABLES, YQLv1Antlr4ParserTABLESAMPLE, YQLv1Antlr4ParserTABLESTORE, YQLv1Antlr4ParserTEMP, YQLv1Antlr4ParserTEMPORARY, YQLv1Antlr4ParserTHEN, YQLv1Antlr4ParserTIES, YQLv1Antlr4ParserTO, YQLv1Antlr4ParserTOPIC, YQLv1Antlr4ParserTRANSACTION, YQLv1Antlr4ParserTRIGGER, YQLv1Antlr4ParserTYPE, YQLv1Antlr4ParserUNCONDITIONAL, YQLv1Antlr4ParserUNIQUE, YQLv1Antlr4ParserUNKNOWN, YQLv1Antlr4ParserUNMATCHED, YQLv1Antlr4ParserUPDATE, YQLv1Antlr4ParserUPSERT, YQLv1Antlr4ParserUSE, YQLv1Antlr4ParserUSER, YQLv1Antlr4ParserUSING, YQLv1Antlr4ParserVACUUM, YQLv1Antlr4ParserVALUES, YQLv1Antlr4ParserVIEW, YQLv1Antlr4ParserVIRTUAL, YQLv1Antlr4ParserWITH, YQLv1Antlr4ParserWRAPPER, YQLv1Antlr4ParserXOR: + case YQLParserABORT, YQLParserACTION, YQLParserADD, YQLParserAFTER, YQLParserALTER, YQLParserANALYZE, YQLParserAND, YQLParserANSI, YQLParserARRAY, YQLParserASC, YQLParserASYNC, YQLParserAT, YQLParserATTACH, YQLParserATTRIBUTES, YQLParserAUTOINCREMENT, YQLParserBACKUP, YQLParserCOLLECTION, YQLParserBEFORE, YQLParserBEGIN, YQLParserBERNOULLI, YQLParserBY, YQLParserCASCADE, YQLParserCHANGEFEED, YQLParserCHECK, YQLParserCLASSIFIER, YQLParserCOLLATE, YQLParserCOMMIT, YQLParserCONDITIONAL, YQLParserCONFLICT, YQLParserCONNECT, YQLParserCONSTRAINT, YQLParserCONSUMER, YQLParserCOVER, YQLParserCREATE, YQLParserCROSS, YQLParserCURRENT, YQLParserDATA, YQLParserDATABASE, YQLParserDECIMAL, YQLParserDECLARE, YQLParserDEFAULT, YQLParserDEFERRABLE, YQLParserDEFERRED, YQLParserDEFINE, YQLParserDELETE, YQLParserDESC, YQLParserDESCRIBE, YQLParserDETACH, YQLParserDIRECTORY, YQLParserDISABLE, YQLParserDISCARD, YQLParserDO, YQLParserDROP, YQLParserEACH, YQLParserELSE, YQLParserEMPTY, YQLParserENCRYPTED, YQLParserEND, YQLParserERROR, YQLParserESCAPE, YQLParserEVALUATE, YQLParserEXCLUDE, YQLParserEXCLUSION, YQLParserEXCLUSIVE, YQLParserEXPLAIN, YQLParserEXPORT, YQLParserEXTERNAL, YQLParserFAIL, YQLParserFAMILY, YQLParserFILTER, YQLParserFIRST, YQLParserFLATTEN, YQLParserFOLLOWING, YQLParserFOR, YQLParserFOREIGN, YQLParserFUNCTION, YQLParserGLOB, YQLParserGLOBAL, YQLParserGRANT, YQLParserGROUP, YQLParserGROUPING, YQLParserHASH, YQLParserIF, YQLParserIGNORE, YQLParserILIKE, YQLParserIMMEDIATE, YQLParserIMPORT, YQLParserIN, YQLParserINCREMENT, YQLParserINCREMENTAL, YQLParserINDEX, YQLParserINDEXED, YQLParserINHERITS, YQLParserINITIAL, YQLParserINITIALLY, YQLParserINNER, YQLParserINSERT, YQLParserINSTEAD, YQLParserINTO, YQLParserIS, YQLParserISNULL, YQLParserJOIN, YQLParserKEY, YQLParserLAST, YQLParserLEFT, YQLParserLEGACY, YQLParserLIKE, YQLParserLOCAL, YQLParserLOGIN, YQLParserMANAGE, YQLParserMATCH, YQLParserMATCHES, YQLParserMATCH_RECOGNIZE, YQLParserMEASURES, YQLParserMICROSECONDS, YQLParserMILLISECONDS, YQLParserMODIFY, YQLParserNANOSECONDS, YQLParserNATURAL, YQLParserNEXT, YQLParserNO, YQLParserNOLOGIN, YQLParserNOTNULL, YQLParserNULLS, YQLParserOBJECT, YQLParserOF, YQLParserOFFSET, YQLParserOMIT, YQLParserON, YQLParserONE, YQLParserONLY, YQLParserOPTION, YQLParserOR, YQLParserORDER, YQLParserOTHERS, YQLParserOUTER, YQLParserOVER, YQLParserPARALLEL, YQLParserPARTITION, YQLParserPASSING, YQLParserPASSWORD, YQLParserPAST, YQLParserPATTERN, YQLParserPER, YQLParserPERMUTE, YQLParserPLAN, YQLParserPOOL, YQLParserPRAGMA, YQLParserPRECEDING, YQLParserPRESORT, YQLParserPRIMARY, YQLParserPRIVILEGES, YQLParserQUERY, YQLParserQUEUE, YQLParserRAISE, YQLParserREFERENCES, YQLParserREGEXP, YQLParserREINDEX, YQLParserRELEASE, YQLParserREMOVE, YQLParserRENAME, YQLParserREPLACE, YQLParserREPLICATION, YQLParserRESET, YQLParserRESPECT, YQLParserRESTART, YQLParserRESTORE, YQLParserRESTRICT, YQLParserRESULT, YQLParserREVERT, YQLParserREVOKE, YQLParserRIGHT, YQLParserRLIKE, YQLParserROLLBACK, YQLParserROW, YQLParserSAMPLE, YQLParserSAVEPOINT, YQLParserSECONDS, YQLParserSEEK, YQLParserSEMI, YQLParserSETS, YQLParserSHOW, YQLParserTSKIP, YQLParserSEQUENCE, YQLParserSOURCE, YQLParserSTART, YQLParserSUBQUERY, YQLParserSUBSET, YQLParserSYMBOLS, YQLParserSYNC, YQLParserSYSTEM, YQLParserTABLE, YQLParserTABLES, YQLParserTABLESAMPLE, YQLParserTABLESTORE, YQLParserTEMP, YQLParserTEMPORARY, YQLParserTHEN, YQLParserTIES, YQLParserTO, YQLParserTOPIC, YQLParserTRANSACTION, YQLParserTRIGGER, YQLParserTYPE, YQLParserUNCONDITIONAL, YQLParserUNIQUE, YQLParserUNKNOWN, YQLParserUNMATCHED, YQLParserUPDATE, YQLParserUPSERT, YQLParserUSE, YQLParserUSER, YQLParserUSING, YQLParserVACUUM, YQLParserVALUES, YQLParserVIEW, YQLParserVIRTUAL, YQLParserWITH, YQLParserWRAPPER, YQLParserXOR: p.EnterOuterAlt(localctx, 1) { p.SetState(4531) @@ -86215,7 +86215,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } - case YQLv1Antlr4ParserASYMMETRIC, YQLv1Antlr4ParserBETWEEN, YQLv1Antlr4ParserBITCAST, YQLv1Antlr4ParserCASE, YQLv1Antlr4ParserCAST, YQLv1Antlr4ParserCUBE, YQLv1Antlr4ParserCURRENT_DATE, YQLv1Antlr4ParserCURRENT_TIME, YQLv1Antlr4ParserCURRENT_TIMESTAMP, YQLv1Antlr4ParserEMPTY_ACTION, YQLv1Antlr4ParserEXISTS, YQLv1Antlr4ParserFROM, YQLv1Antlr4ParserFULL, YQLv1Antlr4ParserHOP, YQLv1Antlr4ParserJSON_EXISTS, YQLv1Antlr4ParserJSON_QUERY, YQLv1Antlr4ParserJSON_VALUE, YQLv1Antlr4ParserNOT, YQLv1Antlr4ParserNULL, YQLv1Antlr4ParserPROCESS, YQLv1Antlr4ParserREDUCE, YQLv1Antlr4ParserRETURN, YQLv1Antlr4ParserRETURNING, YQLv1Antlr4ParserROLLUP, YQLv1Antlr4ParserSELECT, YQLv1Antlr4ParserSYMMETRIC, YQLv1Antlr4ParserUNBOUNDED, YQLv1Antlr4ParserWHEN, YQLv1Antlr4ParserWHERE: + case YQLParserASYMMETRIC, YQLParserBETWEEN, YQLParserBITCAST, YQLParserCASE, YQLParserCAST, YQLParserCUBE, YQLParserCURRENT_DATE, YQLParserCURRENT_TIME, YQLParserCURRENT_TIMESTAMP, YQLParserEMPTY_ACTION, YQLParserEXISTS, YQLParserFROM, YQLParserFULL, YQLParserHOP, YQLParserJSON_EXISTS, YQLParserJSON_QUERY, YQLParserJSON_VALUE, YQLParserNOT, YQLParserNULL, YQLParserPROCESS, YQLParserREDUCE, YQLParserRETURN, YQLParserRETURNING, YQLParserROLLUP, YQLParserSELECT, YQLParserSYMMETRIC, YQLParserUNBOUNDED, YQLParserWHEN, YQLParserWHERE: p.EnterOuterAlt(localctx, 2) { p.SetState(4532) @@ -86223,7 +86223,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } - case YQLv1Antlr4ParserANY, YQLv1Antlr4ParserERASE, YQLv1Antlr4ParserSTREAM: + case YQLParserANY, YQLParserERASE, YQLParserSTREAM: p.EnterOuterAlt(localctx, 3) { p.SetState(4533) @@ -86231,7 +86231,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } - case YQLv1Antlr4ParserALL, YQLv1Antlr4ParserAS, YQLv1Antlr4ParserASSUME, YQLv1Antlr4ParserDISTINCT, YQLv1Antlr4ParserEXCEPT, YQLv1Antlr4ParserHAVING, YQLv1Antlr4ParserINTERSECT, YQLv1Antlr4ParserLIMIT, YQLv1Antlr4ParserUNION, YQLv1Antlr4ParserWINDOW, YQLv1Antlr4ParserWITHOUT: + case YQLParserALL, YQLParserAS, YQLParserASSUME, YQLParserDISTINCT, YQLParserEXCEPT, YQLParserHAVING, YQLParserINTERSECT, YQLParserLIMIT, YQLParserUNION, YQLParserWINDOW, YQLParserWITHOUT: p.EnterOuterAlt(localctx, 4) { p.SetState(4534) @@ -86239,7 +86239,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } - case YQLv1Antlr4ParserCOLUMN: + case YQLParserCOLUMN: p.EnterOuterAlt(localctx, 5) { p.SetState(4535) @@ -86247,7 +86247,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } - case YQLv1Antlr4ParserCOMPACT: + case YQLParserCOMPACT: p.EnterOuterAlt(localctx, 6) { p.SetState(4536) @@ -86255,7 +86255,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } - case YQLv1Antlr4ParserGROUPS, YQLv1Antlr4ParserRANGE, YQLv1Antlr4ParserROWS: + case YQLParserGROUPS, YQLParserRANGE, YQLParserROWS: p.EnterOuterAlt(localctx, 7) { p.SetState(4537) @@ -86263,7 +86263,7 @@ func (p *YQLv1Antlr4Parser) Keyword() (localctx IKeywordContext) { } - case YQLv1Antlr4ParserCOLUMNS, YQLv1Antlr4ParserSCHEMA: + case YQLParserCOLUMNS, YQLParserSCHEMA: p.EnterOuterAlt(localctx, 8) { p.SetState(4538) @@ -86342,13 +86342,13 @@ type Keyword_expr_uncompatContext struct { func NewEmptyKeyword_expr_uncompatContext() *Keyword_expr_uncompatContext { var p = new(Keyword_expr_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_expr_uncompat + p.RuleIndex = YQLParserRULE_keyword_expr_uncompat return p } func InitEmptyKeyword_expr_uncompatContext(p *Keyword_expr_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_expr_uncompat + p.RuleIndex = YQLParserRULE_keyword_expr_uncompat } func (*Keyword_expr_uncompatContext) IsKeyword_expr_uncompatContext() {} @@ -86359,7 +86359,7 @@ func NewKeyword_expr_uncompatContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_expr_uncompat + p.RuleIndex = YQLParserRULE_keyword_expr_uncompat return p } @@ -86367,119 +86367,119 @@ func NewKeyword_expr_uncompatContext(parser antlr.Parser, parent antlr.ParserRul func (s *Keyword_expr_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_expr_uncompatContext) ASYMMETRIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYMMETRIC, 0) + return s.GetToken(YQLParserASYMMETRIC, 0) } func (s *Keyword_expr_uncompatContext) BETWEEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBETWEEN, 0) + return s.GetToken(YQLParserBETWEEN, 0) } func (s *Keyword_expr_uncompatContext) BITCAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBITCAST, 0) + return s.GetToken(YQLParserBITCAST, 0) } func (s *Keyword_expr_uncompatContext) CASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCASE, 0) + return s.GetToken(YQLParserCASE, 0) } func (s *Keyword_expr_uncompatContext) CAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCAST, 0) + return s.GetToken(YQLParserCAST, 0) } func (s *Keyword_expr_uncompatContext) CUBE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCUBE, 0) + return s.GetToken(YQLParserCUBE, 0) } func (s *Keyword_expr_uncompatContext) CURRENT_DATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT_DATE, 0) + return s.GetToken(YQLParserCURRENT_DATE, 0) } func (s *Keyword_expr_uncompatContext) CURRENT_TIME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT_TIME, 0) + return s.GetToken(YQLParserCURRENT_TIME, 0) } func (s *Keyword_expr_uncompatContext) CURRENT_TIMESTAMP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT_TIMESTAMP, 0) + return s.GetToken(YQLParserCURRENT_TIMESTAMP, 0) } func (s *Keyword_expr_uncompatContext) EMPTY_ACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY_ACTION, 0) + return s.GetToken(YQLParserEMPTY_ACTION, 0) } func (s *Keyword_expr_uncompatContext) EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXISTS, 0) + return s.GetToken(YQLParserEXISTS, 0) } func (s *Keyword_expr_uncompatContext) FROM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFROM, 0) + return s.GetToken(YQLParserFROM, 0) } func (s *Keyword_expr_uncompatContext) FULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFULL, 0) + return s.GetToken(YQLParserFULL, 0) } func (s *Keyword_expr_uncompatContext) HOP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHOP, 0) + return s.GetToken(YQLParserHOP, 0) } func (s *Keyword_expr_uncompatContext) JSON_EXISTS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJSON_EXISTS, 0) + return s.GetToken(YQLParserJSON_EXISTS, 0) } func (s *Keyword_expr_uncompatContext) JSON_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJSON_VALUE, 0) + return s.GetToken(YQLParserJSON_VALUE, 0) } func (s *Keyword_expr_uncompatContext) JSON_QUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJSON_QUERY, 0) + return s.GetToken(YQLParserJSON_QUERY, 0) } func (s *Keyword_expr_uncompatContext) NOT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOT, 0) + return s.GetToken(YQLParserNOT, 0) } func (s *Keyword_expr_uncompatContext) NULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULL, 0) + return s.GetToken(YQLParserNULL, 0) } func (s *Keyword_expr_uncompatContext) PROCESS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPROCESS, 0) + return s.GetToken(YQLParserPROCESS, 0) } func (s *Keyword_expr_uncompatContext) REDUCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREDUCE, 0) + return s.GetToken(YQLParserREDUCE, 0) } func (s *Keyword_expr_uncompatContext) RETURN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRETURN, 0) + return s.GetToken(YQLParserRETURN, 0) } func (s *Keyword_expr_uncompatContext) RETURNING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRETURNING, 0) + return s.GetToken(YQLParserRETURNING, 0) } func (s *Keyword_expr_uncompatContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROLLUP, 0) + return s.GetToken(YQLParserROLLUP, 0) } func (s *Keyword_expr_uncompatContext) SELECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSELECT, 0) + return s.GetToken(YQLParserSELECT, 0) } func (s *Keyword_expr_uncompatContext) SYMMETRIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYMMETRIC, 0) + return s.GetToken(YQLParserSYMMETRIC, 0) } func (s *Keyword_expr_uncompatContext) UNBOUNDED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNBOUNDED, 0) + return s.GetToken(YQLParserUNBOUNDED, 0) } func (s *Keyword_expr_uncompatContext) WHEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHEN, 0) + return s.GetToken(YQLParserWHEN, 0) } func (s *Keyword_expr_uncompatContext) WHERE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWHERE, 0) + return s.GetToken(YQLParserWHERE, 0) } func (s *Keyword_expr_uncompatContext) GetRuleContext() antlr.RuleContext { @@ -86492,13 +86492,13 @@ func (s *Keyword_expr_uncompatContext) ToStringTree(ruleNames []string, recog an func (s *Keyword_expr_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_expr_uncompat(s) } } func (s *Keyword_expr_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_expr_uncompat(s) } } @@ -86506,9 +86506,9 @@ func (s *Keyword_expr_uncompatContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Keyword_expr_uncompat() (localctx IKeyword_expr_uncompatContext) { +func (p *YQLParser) Keyword_expr_uncompat() (localctx IKeyword_expr_uncompatContext) { localctx = NewKeyword_expr_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 840, YQLv1Antlr4ParserRULE_keyword_expr_uncompat) + p.EnterRule(localctx, 840, YQLParserRULE_keyword_expr_uncompat) var _la int p.EnterOuterAlt(localctx, 1) @@ -86564,13 +86564,13 @@ type Keyword_table_uncompatContext struct { func NewEmptyKeyword_table_uncompatContext() *Keyword_table_uncompatContext { var p = new(Keyword_table_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_table_uncompat + p.RuleIndex = YQLParserRULE_keyword_table_uncompat return p } func InitEmptyKeyword_table_uncompatContext(p *Keyword_table_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_table_uncompat + p.RuleIndex = YQLParserRULE_keyword_table_uncompat } func (*Keyword_table_uncompatContext) IsKeyword_table_uncompatContext() {} @@ -86581,7 +86581,7 @@ func NewKeyword_table_uncompatContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_table_uncompat + p.RuleIndex = YQLParserRULE_keyword_table_uncompat return p } @@ -86589,15 +86589,15 @@ func NewKeyword_table_uncompatContext(parser antlr.Parser, parent antlr.ParserRu func (s *Keyword_table_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_table_uncompatContext) ANY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANY, 0) + return s.GetToken(YQLParserANY, 0) } func (s *Keyword_table_uncompatContext) ERASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERASE, 0) + return s.GetToken(YQLParserERASE, 0) } func (s *Keyword_table_uncompatContext) STREAM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTREAM, 0) + return s.GetToken(YQLParserSTREAM, 0) } func (s *Keyword_table_uncompatContext) GetRuleContext() antlr.RuleContext { @@ -86610,13 +86610,13 @@ func (s *Keyword_table_uncompatContext) ToStringTree(ruleNames []string, recog a func (s *Keyword_table_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_table_uncompat(s) } } func (s *Keyword_table_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_table_uncompat(s) } } @@ -86624,9 +86624,9 @@ func (s *Keyword_table_uncompatContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Keyword_table_uncompat() (localctx IKeyword_table_uncompatContext) { +func (p *YQLParser) Keyword_table_uncompat() (localctx IKeyword_table_uncompatContext) { localctx = NewKeyword_table_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 842, YQLv1Antlr4ParserRULE_keyword_table_uncompat) + p.EnterRule(localctx, 842, YQLParserRULE_keyword_table_uncompat) var _la int p.EnterOuterAlt(localctx, 1) @@ -86634,7 +86634,7 @@ func (p *YQLv1Antlr4Parser) Keyword_table_uncompat() (localctx IKeyword_table_un p.SetState(4543) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserANY || _la == YQLv1Antlr4ParserERASE || _la == YQLv1Antlr4ParserSTREAM) { + if !(_la == YQLParserANY || _la == YQLParserERASE || _la == YQLParserSTREAM) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -86690,13 +86690,13 @@ type Keyword_select_uncompatContext struct { func NewEmptyKeyword_select_uncompatContext() *Keyword_select_uncompatContext { var p = new(Keyword_select_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_select_uncompat + p.RuleIndex = YQLParserRULE_keyword_select_uncompat return p } func InitEmptyKeyword_select_uncompatContext(p *Keyword_select_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_select_uncompat + p.RuleIndex = YQLParserRULE_keyword_select_uncompat } func (*Keyword_select_uncompatContext) IsKeyword_select_uncompatContext() {} @@ -86707,7 +86707,7 @@ func NewKeyword_select_uncompatContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_select_uncompat + p.RuleIndex = YQLParserRULE_keyword_select_uncompat return p } @@ -86715,47 +86715,47 @@ func NewKeyword_select_uncompatContext(parser antlr.Parser, parent antlr.ParserR func (s *Keyword_select_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_select_uncompatContext) ALL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALL, 0) + return s.GetToken(YQLParserALL, 0) } func (s *Keyword_select_uncompatContext) AS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAS, 0) + return s.GetToken(YQLParserAS, 0) } func (s *Keyword_select_uncompatContext) ASSUME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASSUME, 0) + return s.GetToken(YQLParserASSUME, 0) } func (s *Keyword_select_uncompatContext) DISTINCT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISTINCT, 0) + return s.GetToken(YQLParserDISTINCT, 0) } func (s *Keyword_select_uncompatContext) EXCEPT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCEPT, 0) + return s.GetToken(YQLParserEXCEPT, 0) } func (s *Keyword_select_uncompatContext) HAVING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHAVING, 0) + return s.GetToken(YQLParserHAVING, 0) } func (s *Keyword_select_uncompatContext) INTERSECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINTERSECT, 0) + return s.GetToken(YQLParserINTERSECT, 0) } func (s *Keyword_select_uncompatContext) LIMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIMIT, 0) + return s.GetToken(YQLParserLIMIT, 0) } func (s *Keyword_select_uncompatContext) UNION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNION, 0) + return s.GetToken(YQLParserUNION, 0) } func (s *Keyword_select_uncompatContext) WINDOW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWINDOW, 0) + return s.GetToken(YQLParserWINDOW, 0) } func (s *Keyword_select_uncompatContext) WITHOUT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITHOUT, 0) + return s.GetToken(YQLParserWITHOUT, 0) } func (s *Keyword_select_uncompatContext) GetRuleContext() antlr.RuleContext { @@ -86768,13 +86768,13 @@ func (s *Keyword_select_uncompatContext) ToStringTree(ruleNames []string, recog func (s *Keyword_select_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_select_uncompat(s) } } func (s *Keyword_select_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_select_uncompat(s) } } @@ -86782,9 +86782,9 @@ func (s *Keyword_select_uncompatContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Keyword_select_uncompat() (localctx IKeyword_select_uncompatContext) { +func (p *YQLParser) Keyword_select_uncompat() (localctx IKeyword_select_uncompatContext) { localctx = NewKeyword_select_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 844, YQLv1Antlr4ParserRULE_keyword_select_uncompat) + p.EnterRule(localctx, 844, YQLParserRULE_keyword_select_uncompat) var _la int p.EnterOuterAlt(localctx, 1) @@ -86792,7 +86792,7 @@ func (p *YQLv1Antlr4Parser) Keyword_select_uncompat() (localctx IKeyword_select_ p.SetState(4545) _la = p.GetTokenStream().LA(1) - if !(((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 2819147813617664) != 0) || ((int64((_la - 108)) & ^0x3f) == 0 && ((int64(1) << (_la - 108)) & 1152925902653374465) != 0) || _la == YQLv1Antlr4ParserLIMIT || ((int64((_la - 303)) & ^0x3f) == 0 && ((int64(1) << (_la - 303)) & 327681) != 0)) { + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1) << _la) & 2819147813617664) != 0) || ((int64((_la - 108)) & ^0x3f) == 0 && ((int64(1) << (_la - 108)) & 1152925902653374465) != 0) || _la == YQLParserLIMIT || ((int64((_la - 303)) & ^0x3f) == 0 && ((int64(1) << (_la - 303)) & 327681) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -86838,13 +86838,13 @@ type Keyword_alter_uncompatContext struct { func NewEmptyKeyword_alter_uncompatContext() *Keyword_alter_uncompatContext { var p = new(Keyword_alter_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_alter_uncompat + p.RuleIndex = YQLParserRULE_keyword_alter_uncompat return p } func InitEmptyKeyword_alter_uncompatContext(p *Keyword_alter_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_alter_uncompat + p.RuleIndex = YQLParserRULE_keyword_alter_uncompat } func (*Keyword_alter_uncompatContext) IsKeyword_alter_uncompatContext() {} @@ -86855,7 +86855,7 @@ func NewKeyword_alter_uncompatContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_alter_uncompat + p.RuleIndex = YQLParserRULE_keyword_alter_uncompat return p } @@ -86863,7 +86863,7 @@ func NewKeyword_alter_uncompatContext(parser antlr.Parser, parent antlr.ParserRu func (s *Keyword_alter_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_alter_uncompatContext) COLUMN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMN, 0) + return s.GetToken(YQLParserCOLUMN, 0) } func (s *Keyword_alter_uncompatContext) GetRuleContext() antlr.RuleContext { @@ -86876,13 +86876,13 @@ func (s *Keyword_alter_uncompatContext) ToStringTree(ruleNames []string, recog a func (s *Keyword_alter_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_alter_uncompat(s) } } func (s *Keyword_alter_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_alter_uncompat(s) } } @@ -86890,13 +86890,13 @@ func (s *Keyword_alter_uncompatContext) ExitRule(listener antlr.ParseTreeListene -func (p *YQLv1Antlr4Parser) Keyword_alter_uncompat() (localctx IKeyword_alter_uncompatContext) { +func (p *YQLParser) Keyword_alter_uncompat() (localctx IKeyword_alter_uncompatContext) { localctx = NewKeyword_alter_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 846, YQLv1Antlr4ParserRULE_keyword_alter_uncompat) + p.EnterRule(localctx, 846, YQLParserRULE_keyword_alter_uncompat) p.EnterOuterAlt(localctx, 1) { p.SetState(4547) - p.Match(YQLv1Antlr4ParserCOLUMN) + p.Match(YQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86941,13 +86941,13 @@ type Keyword_in_uncompatContext struct { func NewEmptyKeyword_in_uncompatContext() *Keyword_in_uncompatContext { var p = new(Keyword_in_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_in_uncompat + p.RuleIndex = YQLParserRULE_keyword_in_uncompat return p } func InitEmptyKeyword_in_uncompatContext(p *Keyword_in_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_in_uncompat + p.RuleIndex = YQLParserRULE_keyword_in_uncompat } func (*Keyword_in_uncompatContext) IsKeyword_in_uncompatContext() {} @@ -86958,7 +86958,7 @@ func NewKeyword_in_uncompatContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_in_uncompat + p.RuleIndex = YQLParserRULE_keyword_in_uncompat return p } @@ -86966,7 +86966,7 @@ func NewKeyword_in_uncompatContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *Keyword_in_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_in_uncompatContext) COMPACT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMPACT, 0) + return s.GetToken(YQLParserCOMPACT, 0) } func (s *Keyword_in_uncompatContext) GetRuleContext() antlr.RuleContext { @@ -86979,13 +86979,13 @@ func (s *Keyword_in_uncompatContext) ToStringTree(ruleNames []string, recog antl func (s *Keyword_in_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_in_uncompat(s) } } func (s *Keyword_in_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_in_uncompat(s) } } @@ -86993,13 +86993,13 @@ func (s *Keyword_in_uncompatContext) ExitRule(listener antlr.ParseTreeListener) -func (p *YQLv1Antlr4Parser) Keyword_in_uncompat() (localctx IKeyword_in_uncompatContext) { +func (p *YQLParser) Keyword_in_uncompat() (localctx IKeyword_in_uncompatContext) { localctx = NewKeyword_in_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 848, YQLv1Antlr4ParserRULE_keyword_in_uncompat) + p.EnterRule(localctx, 848, YQLParserRULE_keyword_in_uncompat) p.EnterOuterAlt(localctx, 1) { p.SetState(4549) - p.Match(YQLv1Antlr4ParserCOMPACT) + p.Match(YQLParserCOMPACT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87046,13 +87046,13 @@ type Keyword_window_uncompatContext struct { func NewEmptyKeyword_window_uncompatContext() *Keyword_window_uncompatContext { var p = new(Keyword_window_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_window_uncompat + p.RuleIndex = YQLParserRULE_keyword_window_uncompat return p } func InitEmptyKeyword_window_uncompatContext(p *Keyword_window_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_window_uncompat + p.RuleIndex = YQLParserRULE_keyword_window_uncompat } func (*Keyword_window_uncompatContext) IsKeyword_window_uncompatContext() {} @@ -87063,7 +87063,7 @@ func NewKeyword_window_uncompatContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_window_uncompat + p.RuleIndex = YQLParserRULE_keyword_window_uncompat return p } @@ -87071,15 +87071,15 @@ func NewKeyword_window_uncompatContext(parser antlr.Parser, parent antlr.ParserR func (s *Keyword_window_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_window_uncompatContext) GROUPS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUPS, 0) + return s.GetToken(YQLParserGROUPS, 0) } func (s *Keyword_window_uncompatContext) RANGE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRANGE, 0) + return s.GetToken(YQLParserRANGE, 0) } func (s *Keyword_window_uncompatContext) ROWS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROWS, 0) + return s.GetToken(YQLParserROWS, 0) } func (s *Keyword_window_uncompatContext) GetRuleContext() antlr.RuleContext { @@ -87092,13 +87092,13 @@ func (s *Keyword_window_uncompatContext) ToStringTree(ruleNames []string, recog func (s *Keyword_window_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_window_uncompat(s) } } func (s *Keyword_window_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_window_uncompat(s) } } @@ -87106,9 +87106,9 @@ func (s *Keyword_window_uncompatContext) ExitRule(listener antlr.ParseTreeListen -func (p *YQLv1Antlr4Parser) Keyword_window_uncompat() (localctx IKeyword_window_uncompatContext) { +func (p *YQLParser) Keyword_window_uncompat() (localctx IKeyword_window_uncompatContext) { localctx = NewKeyword_window_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 850, YQLv1Antlr4ParserRULE_keyword_window_uncompat) + p.EnterRule(localctx, 850, YQLParserRULE_keyword_window_uncompat) var _la int p.EnterOuterAlt(localctx, 1) @@ -87116,7 +87116,7 @@ func (p *YQLv1Antlr4Parser) Keyword_window_uncompat() (localctx IKeyword_window_ p.SetState(4551) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserGROUPS || _la == YQLv1Antlr4ParserRANGE || _la == YQLv1Antlr4ParserROWS) { + if !(_la == YQLParserGROUPS || _la == YQLParserRANGE || _la == YQLParserROWS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -87163,13 +87163,13 @@ type Keyword_hint_uncompatContext struct { func NewEmptyKeyword_hint_uncompatContext() *Keyword_hint_uncompatContext { var p = new(Keyword_hint_uncompatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_hint_uncompat + p.RuleIndex = YQLParserRULE_keyword_hint_uncompat return p } func InitEmptyKeyword_hint_uncompatContext(p *Keyword_hint_uncompatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_hint_uncompat + p.RuleIndex = YQLParserRULE_keyword_hint_uncompat } func (*Keyword_hint_uncompatContext) IsKeyword_hint_uncompatContext() {} @@ -87180,7 +87180,7 @@ func NewKeyword_hint_uncompatContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_hint_uncompat + p.RuleIndex = YQLParserRULE_keyword_hint_uncompat return p } @@ -87188,11 +87188,11 @@ func NewKeyword_hint_uncompatContext(parser antlr.Parser, parent antlr.ParserRul func (s *Keyword_hint_uncompatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_hint_uncompatContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSCHEMA, 0) + return s.GetToken(YQLParserSCHEMA, 0) } func (s *Keyword_hint_uncompatContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLUMNS, 0) + return s.GetToken(YQLParserCOLUMNS, 0) } func (s *Keyword_hint_uncompatContext) GetRuleContext() antlr.RuleContext { @@ -87205,13 +87205,13 @@ func (s *Keyword_hint_uncompatContext) ToStringTree(ruleNames []string, recog an func (s *Keyword_hint_uncompatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_hint_uncompat(s) } } func (s *Keyword_hint_uncompatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_hint_uncompat(s) } } @@ -87219,9 +87219,9 @@ func (s *Keyword_hint_uncompatContext) ExitRule(listener antlr.ParseTreeListener -func (p *YQLv1Antlr4Parser) Keyword_hint_uncompat() (localctx IKeyword_hint_uncompatContext) { +func (p *YQLParser) Keyword_hint_uncompat() (localctx IKeyword_hint_uncompatContext) { localctx = NewKeyword_hint_uncompatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 852, YQLv1Antlr4ParserRULE_keyword_hint_uncompat) + p.EnterRule(localctx, 852, YQLParserRULE_keyword_hint_uncompat) var _la int p.EnterOuterAlt(localctx, 1) @@ -87229,7 +87229,7 @@ func (p *YQLv1Antlr4Parser) Keyword_hint_uncompat() (localctx IKeyword_hint_unco p.SetState(4553) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserCOLUMNS || _la == YQLv1Antlr4ParserSCHEMA) { + if !(_la == YQLParserCOLUMNS || _la == YQLParserSCHEMA) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -87471,13 +87471,13 @@ type Keyword_as_compatContext struct { func NewEmptyKeyword_as_compatContext() *Keyword_as_compatContext { var p = new(Keyword_as_compatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_as_compat + p.RuleIndex = YQLParserRULE_keyword_as_compat return p } func InitEmptyKeyword_as_compatContext(p *Keyword_as_compatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_as_compat + p.RuleIndex = YQLParserRULE_keyword_as_compat } func (*Keyword_as_compatContext) IsKeyword_as_compatContext() {} @@ -87488,7 +87488,7 @@ func NewKeyword_as_compatContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_as_compat + p.RuleIndex = YQLParserRULE_keyword_as_compat return p } @@ -87496,791 +87496,791 @@ func NewKeyword_as_compatContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *Keyword_as_compatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_as_compatContext) ABORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserABORT, 0) + return s.GetToken(YQLParserABORT, 0) } func (s *Keyword_as_compatContext) ACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserACTION, 0) + return s.GetToken(YQLParserACTION, 0) } func (s *Keyword_as_compatContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Keyword_as_compatContext) AFTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAFTER, 0) + return s.GetToken(YQLParserAFTER, 0) } func (s *Keyword_as_compatContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Keyword_as_compatContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANALYZE, 0) + return s.GetToken(YQLParserANALYZE, 0) } func (s *Keyword_as_compatContext) AND() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAND, 0) + return s.GetToken(YQLParserAND, 0) } func (s *Keyword_as_compatContext) ANSI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANSI, 0) + return s.GetToken(YQLParserANSI, 0) } func (s *Keyword_as_compatContext) ARRAY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserARRAY, 0) + return s.GetToken(YQLParserARRAY, 0) } func (s *Keyword_as_compatContext) ASC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASC, 0) + return s.GetToken(YQLParserASC, 0) } func (s *Keyword_as_compatContext) ASYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYNC, 0) + return s.GetToken(YQLParserASYNC, 0) } func (s *Keyword_as_compatContext) AT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAT, 0) + return s.GetToken(YQLParserAT, 0) } func (s *Keyword_as_compatContext) ATTACH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserATTACH, 0) + return s.GetToken(YQLParserATTACH, 0) } func (s *Keyword_as_compatContext) ATTRIBUTES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserATTRIBUTES, 0) + return s.GetToken(YQLParserATTRIBUTES, 0) } func (s *Keyword_as_compatContext) AUTOINCREMENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAUTOINCREMENT, 0) + return s.GetToken(YQLParserAUTOINCREMENT, 0) } func (s *Keyword_as_compatContext) BACKUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBACKUP, 0) + return s.GetToken(YQLParserBACKUP, 0) } func (s *Keyword_as_compatContext) BEFORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBEFORE, 0) + return s.GetToken(YQLParserBEFORE, 0) } func (s *Keyword_as_compatContext) BEGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBEGIN, 0) + return s.GetToken(YQLParserBEGIN, 0) } func (s *Keyword_as_compatContext) BERNOULLI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBERNOULLI, 0) + return s.GetToken(YQLParserBERNOULLI, 0) } func (s *Keyword_as_compatContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Keyword_as_compatContext) CASCADE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCASCADE, 0) + return s.GetToken(YQLParserCASCADE, 0) } func (s *Keyword_as_compatContext) CHANGEFEED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCHANGEFEED, 0) + return s.GetToken(YQLParserCHANGEFEED, 0) } func (s *Keyword_as_compatContext) CHECK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCHECK, 0) + return s.GetToken(YQLParserCHECK, 0) } func (s *Keyword_as_compatContext) CLASSIFIER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCLASSIFIER, 0) + return s.GetToken(YQLParserCLASSIFIER, 0) } func (s *Keyword_as_compatContext) COLLECTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLLECTION, 0) + return s.GetToken(YQLParserCOLLECTION, 0) } func (s *Keyword_as_compatContext) COMMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMIT, 0) + return s.GetToken(YQLParserCOMMIT, 0) } func (s *Keyword_as_compatContext) CONDITIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONDITIONAL, 0) + return s.GetToken(YQLParserCONDITIONAL, 0) } func (s *Keyword_as_compatContext) CONFLICT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONFLICT, 0) + return s.GetToken(YQLParserCONFLICT, 0) } func (s *Keyword_as_compatContext) CONNECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONNECT, 0) + return s.GetToken(YQLParserCONNECT, 0) } func (s *Keyword_as_compatContext) CONSTRAINT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONSTRAINT, 0) + return s.GetToken(YQLParserCONSTRAINT, 0) } func (s *Keyword_as_compatContext) CONSUMER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONSUMER, 0) + return s.GetToken(YQLParserCONSUMER, 0) } func (s *Keyword_as_compatContext) COVER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOVER, 0) + return s.GetToken(YQLParserCOVER, 0) } func (s *Keyword_as_compatContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Keyword_as_compatContext) CURRENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT, 0) + return s.GetToken(YQLParserCURRENT, 0) } func (s *Keyword_as_compatContext) DATA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATA, 0) + return s.GetToken(YQLParserDATA, 0) } func (s *Keyword_as_compatContext) DATABASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATABASE, 0) + return s.GetToken(YQLParserDATABASE, 0) } func (s *Keyword_as_compatContext) DECIMAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDECIMAL, 0) + return s.GetToken(YQLParserDECIMAL, 0) } func (s *Keyword_as_compatContext) DECLARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDECLARE, 0) + return s.GetToken(YQLParserDECLARE, 0) } func (s *Keyword_as_compatContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFAULT, 0) + return s.GetToken(YQLParserDEFAULT, 0) } func (s *Keyword_as_compatContext) DEFERRABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFERRABLE, 0) + return s.GetToken(YQLParserDEFERRABLE, 0) } func (s *Keyword_as_compatContext) DEFERRED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFERRED, 0) + return s.GetToken(YQLParserDEFERRED, 0) } func (s *Keyword_as_compatContext) DELETE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDELETE, 0) + return s.GetToken(YQLParserDELETE, 0) } func (s *Keyword_as_compatContext) DESC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDESC, 0) + return s.GetToken(YQLParserDESC, 0) } func (s *Keyword_as_compatContext) DESCRIBE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDESCRIBE, 0) + return s.GetToken(YQLParserDESCRIBE, 0) } func (s *Keyword_as_compatContext) DETACH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDETACH, 0) + return s.GetToken(YQLParserDETACH, 0) } func (s *Keyword_as_compatContext) DIRECTORY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDIRECTORY, 0) + return s.GetToken(YQLParserDIRECTORY, 0) } func (s *Keyword_as_compatContext) DISABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISABLE, 0) + return s.GetToken(YQLParserDISABLE, 0) } func (s *Keyword_as_compatContext) DISCARD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISCARD, 0) + return s.GetToken(YQLParserDISCARD, 0) } func (s *Keyword_as_compatContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Keyword_as_compatContext) EACH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEACH, 0) + return s.GetToken(YQLParserEACH, 0) } func (s *Keyword_as_compatContext) ELSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserELSE, 0) + return s.GetToken(YQLParserELSE, 0) } func (s *Keyword_as_compatContext) EMPTY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY, 0) + return s.GetToken(YQLParserEMPTY, 0) } func (s *Keyword_as_compatContext) ENCRYPTED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserENCRYPTED, 0) + return s.GetToken(YQLParserENCRYPTED, 0) } func (s *Keyword_as_compatContext) END() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEND, 0) + return s.GetToken(YQLParserEND, 0) } func (s *Keyword_as_compatContext) ERROR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERROR, 0) + return s.GetToken(YQLParserERROR, 0) } func (s *Keyword_as_compatContext) ESCAPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserESCAPE, 0) + return s.GetToken(YQLParserESCAPE, 0) } func (s *Keyword_as_compatContext) EVALUATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEVALUATE, 0) + return s.GetToken(YQLParserEVALUATE, 0) } func (s *Keyword_as_compatContext) EXCLUDE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCLUDE, 0) + return s.GetToken(YQLParserEXCLUDE, 0) } func (s *Keyword_as_compatContext) EXCLUSIVE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCLUSIVE, 0) + return s.GetToken(YQLParserEXCLUSIVE, 0) } func (s *Keyword_as_compatContext) EXPLAIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXPLAIN, 0) + return s.GetToken(YQLParserEXPLAIN, 0) } func (s *Keyword_as_compatContext) EXPORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXPORT, 0) + return s.GetToken(YQLParserEXPORT, 0) } func (s *Keyword_as_compatContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Keyword_as_compatContext) FAIL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFAIL, 0) + return s.GetToken(YQLParserFAIL, 0) } func (s *Keyword_as_compatContext) FAMILY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFAMILY, 0) + return s.GetToken(YQLParserFAMILY, 0) } func (s *Keyword_as_compatContext) FILTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFILTER, 0) + return s.GetToken(YQLParserFILTER, 0) } func (s *Keyword_as_compatContext) FIRST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFIRST, 0) + return s.GetToken(YQLParserFIRST, 0) } func (s *Keyword_as_compatContext) FLATTEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFLATTEN, 0) + return s.GetToken(YQLParserFLATTEN, 0) } func (s *Keyword_as_compatContext) FOLLOWING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOLLOWING, 0) + return s.GetToken(YQLParserFOLLOWING, 0) } func (s *Keyword_as_compatContext) FOR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOR, 0) + return s.GetToken(YQLParserFOR, 0) } func (s *Keyword_as_compatContext) FOREIGN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOREIGN, 0) + return s.GetToken(YQLParserFOREIGN, 0) } func (s *Keyword_as_compatContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFUNCTION, 0) + return s.GetToken(YQLParserFUNCTION, 0) } func (s *Keyword_as_compatContext) GLOB() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGLOB, 0) + return s.GetToken(YQLParserGLOB, 0) } func (s *Keyword_as_compatContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGLOBAL, 0) + return s.GetToken(YQLParserGLOBAL, 0) } func (s *Keyword_as_compatContext) GRANT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGRANT, 0) + return s.GetToken(YQLParserGRANT, 0) } func (s *Keyword_as_compatContext) GROUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUP, 0) + return s.GetToken(YQLParserGROUP, 0) } func (s *Keyword_as_compatContext) GROUPING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUPING, 0) + return s.GetToken(YQLParserGROUPING, 0) } func (s *Keyword_as_compatContext) HASH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHASH, 0) + return s.GetToken(YQLParserHASH, 0) } func (s *Keyword_as_compatContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Keyword_as_compatContext) IGNORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIGNORE, 0) + return s.GetToken(YQLParserIGNORE, 0) } func (s *Keyword_as_compatContext) ILIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserILIKE, 0) + return s.GetToken(YQLParserILIKE, 0) } func (s *Keyword_as_compatContext) IMMEDIATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIMMEDIATE, 0) + return s.GetToken(YQLParserIMMEDIATE, 0) } func (s *Keyword_as_compatContext) IMPORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIMPORT, 0) + return s.GetToken(YQLParserIMPORT, 0) } func (s *Keyword_as_compatContext) IN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIN, 0) + return s.GetToken(YQLParserIN, 0) } func (s *Keyword_as_compatContext) INCREMENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINCREMENT, 0) + return s.GetToken(YQLParserINCREMENT, 0) } func (s *Keyword_as_compatContext) INCREMENTAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINCREMENTAL, 0) + return s.GetToken(YQLParserINCREMENTAL, 0) } func (s *Keyword_as_compatContext) INDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEX, 0) + return s.GetToken(YQLParserINDEX, 0) } func (s *Keyword_as_compatContext) INDEXED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEXED, 0) + return s.GetToken(YQLParserINDEXED, 0) } func (s *Keyword_as_compatContext) INHERITS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINHERITS, 0) + return s.GetToken(YQLParserINHERITS, 0) } func (s *Keyword_as_compatContext) INITIAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINITIAL, 0) + return s.GetToken(YQLParserINITIAL, 0) } func (s *Keyword_as_compatContext) INITIALLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINITIALLY, 0) + return s.GetToken(YQLParserINITIALLY, 0) } func (s *Keyword_as_compatContext) INSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINSERT, 0) + return s.GetToken(YQLParserINSERT, 0) } func (s *Keyword_as_compatContext) INSTEAD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINSTEAD, 0) + return s.GetToken(YQLParserINSTEAD, 0) } func (s *Keyword_as_compatContext) INTO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINTO, 0) + return s.GetToken(YQLParserINTO, 0) } func (s *Keyword_as_compatContext) IS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIS, 0) + return s.GetToken(YQLParserIS, 0) } func (s *Keyword_as_compatContext) LAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLAST, 0) + return s.GetToken(YQLParserLAST, 0) } func (s *Keyword_as_compatContext) LEGACY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLEGACY, 0) + return s.GetToken(YQLParserLEGACY, 0) } func (s *Keyword_as_compatContext) LIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIKE, 0) + return s.GetToken(YQLParserLIKE, 0) } func (s *Keyword_as_compatContext) LOCAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLOCAL, 0) + return s.GetToken(YQLParserLOCAL, 0) } func (s *Keyword_as_compatContext) LOGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLOGIN, 0) + return s.GetToken(YQLParserLOGIN, 0) } func (s *Keyword_as_compatContext) MANAGE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMANAGE, 0) + return s.GetToken(YQLParserMANAGE, 0) } func (s *Keyword_as_compatContext) MATCH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH, 0) + return s.GetToken(YQLParserMATCH, 0) } func (s *Keyword_as_compatContext) MATCHES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCHES, 0) + return s.GetToken(YQLParserMATCHES, 0) } func (s *Keyword_as_compatContext) MATCH_RECOGNIZE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH_RECOGNIZE, 0) + return s.GetToken(YQLParserMATCH_RECOGNIZE, 0) } func (s *Keyword_as_compatContext) MEASURES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMEASURES, 0) + return s.GetToken(YQLParserMEASURES, 0) } func (s *Keyword_as_compatContext) MICROSECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMICROSECONDS, 0) + return s.GetToken(YQLParserMICROSECONDS, 0) } func (s *Keyword_as_compatContext) MILLISECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMILLISECONDS, 0) + return s.GetToken(YQLParserMILLISECONDS, 0) } func (s *Keyword_as_compatContext) MODIFY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMODIFY, 0) + return s.GetToken(YQLParserMODIFY, 0) } func (s *Keyword_as_compatContext) NANOSECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNANOSECONDS, 0) + return s.GetToken(YQLParserNANOSECONDS, 0) } func (s *Keyword_as_compatContext) NEXT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNEXT, 0) + return s.GetToken(YQLParserNEXT, 0) } func (s *Keyword_as_compatContext) NO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNO, 0) + return s.GetToken(YQLParserNO, 0) } func (s *Keyword_as_compatContext) NOLOGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOLOGIN, 0) + return s.GetToken(YQLParserNOLOGIN, 0) } func (s *Keyword_as_compatContext) NULLS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULLS, 0) + return s.GetToken(YQLParserNULLS, 0) } func (s *Keyword_as_compatContext) OBJECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOBJECT, 0) + return s.GetToken(YQLParserOBJECT, 0) } func (s *Keyword_as_compatContext) OF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOF, 0) + return s.GetToken(YQLParserOF, 0) } func (s *Keyword_as_compatContext) OFFSET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOFFSET, 0) + return s.GetToken(YQLParserOFFSET, 0) } func (s *Keyword_as_compatContext) OMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOMIT, 0) + return s.GetToken(YQLParserOMIT, 0) } func (s *Keyword_as_compatContext) ONE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserONE, 0) + return s.GetToken(YQLParserONE, 0) } func (s *Keyword_as_compatContext) ONLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserONLY, 0) + return s.GetToken(YQLParserONLY, 0) } func (s *Keyword_as_compatContext) OPTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOPTION, 0) + return s.GetToken(YQLParserOPTION, 0) } func (s *Keyword_as_compatContext) OR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOR, 0) + return s.GetToken(YQLParserOR, 0) } func (s *Keyword_as_compatContext) ORDER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserORDER, 0) + return s.GetToken(YQLParserORDER, 0) } func (s *Keyword_as_compatContext) OTHERS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOTHERS, 0) + return s.GetToken(YQLParserOTHERS, 0) } func (s *Keyword_as_compatContext) PARALLEL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARALLEL, 0) + return s.GetToken(YQLParserPARALLEL, 0) } func (s *Keyword_as_compatContext) PARTITION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARTITION, 0) + return s.GetToken(YQLParserPARTITION, 0) } func (s *Keyword_as_compatContext) PASSING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPASSING, 0) + return s.GetToken(YQLParserPASSING, 0) } func (s *Keyword_as_compatContext) PASSWORD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPASSWORD, 0) + return s.GetToken(YQLParserPASSWORD, 0) } func (s *Keyword_as_compatContext) PAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPAST, 0) + return s.GetToken(YQLParserPAST, 0) } func (s *Keyword_as_compatContext) PATTERN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPATTERN, 0) + return s.GetToken(YQLParserPATTERN, 0) } func (s *Keyword_as_compatContext) PER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPER, 0) + return s.GetToken(YQLParserPER, 0) } func (s *Keyword_as_compatContext) PERMUTE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPERMUTE, 0) + return s.GetToken(YQLParserPERMUTE, 0) } func (s *Keyword_as_compatContext) PLAN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPLAN, 0) + return s.GetToken(YQLParserPLAN, 0) } func (s *Keyword_as_compatContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Keyword_as_compatContext) PRAGMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRAGMA, 0) + return s.GetToken(YQLParserPRAGMA, 0) } func (s *Keyword_as_compatContext) PRECEDING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRECEDING, 0) + return s.GetToken(YQLParserPRECEDING, 0) } func (s *Keyword_as_compatContext) PRIMARY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRIMARY, 0) + return s.GetToken(YQLParserPRIMARY, 0) } func (s *Keyword_as_compatContext) PRIVILEGES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRIVILEGES, 0) + return s.GetToken(YQLParserPRIVILEGES, 0) } func (s *Keyword_as_compatContext) QUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUERY, 0) + return s.GetToken(YQLParserQUERY, 0) } func (s *Keyword_as_compatContext) QUEUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUEUE, 0) + return s.GetToken(YQLParserQUEUE, 0) } func (s *Keyword_as_compatContext) RAISE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRAISE, 0) + return s.GetToken(YQLParserRAISE, 0) } func (s *Keyword_as_compatContext) REFERENCES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREFERENCES, 0) + return s.GetToken(YQLParserREFERENCES, 0) } func (s *Keyword_as_compatContext) REGEXP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREGEXP, 0) + return s.GetToken(YQLParserREGEXP, 0) } func (s *Keyword_as_compatContext) REINDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREINDEX, 0) + return s.GetToken(YQLParserREINDEX, 0) } func (s *Keyword_as_compatContext) RELEASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRELEASE, 0) + return s.GetToken(YQLParserRELEASE, 0) } func (s *Keyword_as_compatContext) REMOVE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREMOVE, 0) + return s.GetToken(YQLParserREMOVE, 0) } func (s *Keyword_as_compatContext) RENAME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRENAME, 0) + return s.GetToken(YQLParserRENAME, 0) } func (s *Keyword_as_compatContext) REPLACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLACE, 0) + return s.GetToken(YQLParserREPLACE, 0) } func (s *Keyword_as_compatContext) REPLICATION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLICATION, 0) + return s.GetToken(YQLParserREPLICATION, 0) } func (s *Keyword_as_compatContext) RESET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESET, 0) + return s.GetToken(YQLParserRESET, 0) } func (s *Keyword_as_compatContext) RESPECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESPECT, 0) + return s.GetToken(YQLParserRESPECT, 0) } func (s *Keyword_as_compatContext) RESTART() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTART, 0) + return s.GetToken(YQLParserRESTART, 0) } func (s *Keyword_as_compatContext) RESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTORE, 0) + return s.GetToken(YQLParserRESTORE, 0) } func (s *Keyword_as_compatContext) RESTRICT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTRICT, 0) + return s.GetToken(YQLParserRESTRICT, 0) } func (s *Keyword_as_compatContext) REVERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREVERT, 0) + return s.GetToken(YQLParserREVERT, 0) } func (s *Keyword_as_compatContext) REVOKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREVOKE, 0) + return s.GetToken(YQLParserREVOKE, 0) } func (s *Keyword_as_compatContext) RLIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRLIKE, 0) + return s.GetToken(YQLParserRLIKE, 0) } func (s *Keyword_as_compatContext) ROLLBACK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROLLBACK, 0) + return s.GetToken(YQLParserROLLBACK, 0) } func (s *Keyword_as_compatContext) ROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROW, 0) + return s.GetToken(YQLParserROW, 0) } func (s *Keyword_as_compatContext) SAVEPOINT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSAVEPOINT, 0) + return s.GetToken(YQLParserSAVEPOINT, 0) } func (s *Keyword_as_compatContext) SECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSECONDS, 0) + return s.GetToken(YQLParserSECONDS, 0) } func (s *Keyword_as_compatContext) SEEK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEEK, 0) + return s.GetToken(YQLParserSEEK, 0) } func (s *Keyword_as_compatContext) SETS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSETS, 0) + return s.GetToken(YQLParserSETS, 0) } func (s *Keyword_as_compatContext) SHOW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSHOW, 0) + return s.GetToken(YQLParserSHOW, 0) } func (s *Keyword_as_compatContext) TSKIP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTSKIP, 0) + return s.GetToken(YQLParserTSKIP, 0) } func (s *Keyword_as_compatContext) SEQUENCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEQUENCE, 0) + return s.GetToken(YQLParserSEQUENCE, 0) } func (s *Keyword_as_compatContext) SOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSOURCE, 0) + return s.GetToken(YQLParserSOURCE, 0) } func (s *Keyword_as_compatContext) START() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTART, 0) + return s.GetToken(YQLParserSTART, 0) } func (s *Keyword_as_compatContext) SUBQUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSUBQUERY, 0) + return s.GetToken(YQLParserSUBQUERY, 0) } func (s *Keyword_as_compatContext) SUBSET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSUBSET, 0) + return s.GetToken(YQLParserSUBSET, 0) } func (s *Keyword_as_compatContext) SYMBOLS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYMBOLS, 0) + return s.GetToken(YQLParserSYMBOLS, 0) } func (s *Keyword_as_compatContext) SYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYNC, 0) + return s.GetToken(YQLParserSYNC, 0) } func (s *Keyword_as_compatContext) SYSTEM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYSTEM, 0) + return s.GetToken(YQLParserSYSTEM, 0) } func (s *Keyword_as_compatContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Keyword_as_compatContext) TABLES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLES, 0) + return s.GetToken(YQLParserTABLES, 0) } func (s *Keyword_as_compatContext) TABLESAMPLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESAMPLE, 0) + return s.GetToken(YQLParserTABLESAMPLE, 0) } func (s *Keyword_as_compatContext) TABLESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESTORE, 0) + return s.GetToken(YQLParserTABLESTORE, 0) } func (s *Keyword_as_compatContext) TEMP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTEMP, 0) + return s.GetToken(YQLParserTEMP, 0) } func (s *Keyword_as_compatContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTEMPORARY, 0) + return s.GetToken(YQLParserTEMPORARY, 0) } func (s *Keyword_as_compatContext) THEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTHEN, 0) + return s.GetToken(YQLParserTHEN, 0) } func (s *Keyword_as_compatContext) TIES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTIES, 0) + return s.GetToken(YQLParserTIES, 0) } func (s *Keyword_as_compatContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Keyword_as_compatContext) TOPIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTOPIC, 0) + return s.GetToken(YQLParserTOPIC, 0) } func (s *Keyword_as_compatContext) TRANSACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTRANSACTION, 0) + return s.GetToken(YQLParserTRANSACTION, 0) } func (s *Keyword_as_compatContext) TRIGGER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTRIGGER, 0) + return s.GetToken(YQLParserTRIGGER, 0) } func (s *Keyword_as_compatContext) TYPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTYPE, 0) + return s.GetToken(YQLParserTYPE, 0) } func (s *Keyword_as_compatContext) UNCONDITIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNCONDITIONAL, 0) + return s.GetToken(YQLParserUNCONDITIONAL, 0) } func (s *Keyword_as_compatContext) UNIQUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNIQUE, 0) + return s.GetToken(YQLParserUNIQUE, 0) } func (s *Keyword_as_compatContext) UNKNOWN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNKNOWN, 0) + return s.GetToken(YQLParserUNKNOWN, 0) } func (s *Keyword_as_compatContext) UNMATCHED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNMATCHED, 0) + return s.GetToken(YQLParserUNMATCHED, 0) } func (s *Keyword_as_compatContext) UPDATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPDATE, 0) + return s.GetToken(YQLParserUPDATE, 0) } func (s *Keyword_as_compatContext) UPSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPSERT, 0) + return s.GetToken(YQLParserUPSERT, 0) } func (s *Keyword_as_compatContext) USE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSE, 0) + return s.GetToken(YQLParserUSE, 0) } func (s *Keyword_as_compatContext) USER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSER, 0) + return s.GetToken(YQLParserUSER, 0) } func (s *Keyword_as_compatContext) VACUUM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVACUUM, 0) + return s.GetToken(YQLParserVACUUM, 0) } func (s *Keyword_as_compatContext) VALUES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVALUES, 0) + return s.GetToken(YQLParserVALUES, 0) } func (s *Keyword_as_compatContext) VIRTUAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIRTUAL, 0) + return s.GetToken(YQLParserVIRTUAL, 0) } func (s *Keyword_as_compatContext) WRAPPER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWRAPPER, 0) + return s.GetToken(YQLParserWRAPPER, 0) } func (s *Keyword_as_compatContext) XOR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserXOR, 0) + return s.GetToken(YQLParserXOR, 0) } func (s *Keyword_as_compatContext) GetRuleContext() antlr.RuleContext { @@ -88293,13 +88293,13 @@ func (s *Keyword_as_compatContext) ToStringTree(ruleNames []string, recog antlr. func (s *Keyword_as_compatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_as_compat(s) } } func (s *Keyword_as_compatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_as_compat(s) } } @@ -88307,9 +88307,9 @@ func (s *Keyword_as_compatContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Keyword_as_compat() (localctx IKeyword_as_compatContext) { +func (p *YQLParser) Keyword_as_compat() (localctx IKeyword_as_compatContext) { localctx = NewKeyword_as_compatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 854, YQLv1Antlr4ParserRULE_keyword_as_compat) + p.EnterRule(localctx, 854, YQLParserRULE_keyword_as_compat) var _la int p.EnterOuterAlt(localctx, 1) @@ -88582,13 +88582,13 @@ type Keyword_compatContext struct { func NewEmptyKeyword_compatContext() *Keyword_compatContext { var p = new(Keyword_compatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_compat + p.RuleIndex = YQLParserRULE_keyword_compat return p } func InitEmptyKeyword_compatContext(p *Keyword_compatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_compat + p.RuleIndex = YQLParserRULE_keyword_compat } func (*Keyword_compatContext) IsKeyword_compatContext() {} @@ -88599,7 +88599,7 @@ func NewKeyword_compatContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_keyword_compat + p.RuleIndex = YQLParserRULE_keyword_compat return p } @@ -88607,883 +88607,883 @@ func NewKeyword_compatContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *Keyword_compatContext) GetParser() antlr.Parser { return s.parser } func (s *Keyword_compatContext) ABORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserABORT, 0) + return s.GetToken(YQLParserABORT, 0) } func (s *Keyword_compatContext) ACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserACTION, 0) + return s.GetToken(YQLParserACTION, 0) } func (s *Keyword_compatContext) ADD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserADD, 0) + return s.GetToken(YQLParserADD, 0) } func (s *Keyword_compatContext) AFTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAFTER, 0) + return s.GetToken(YQLParserAFTER, 0) } func (s *Keyword_compatContext) ALTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserALTER, 0) + return s.GetToken(YQLParserALTER, 0) } func (s *Keyword_compatContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANALYZE, 0) + return s.GetToken(YQLParserANALYZE, 0) } func (s *Keyword_compatContext) AND() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAND, 0) + return s.GetToken(YQLParserAND, 0) } func (s *Keyword_compatContext) ANSI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserANSI, 0) + return s.GetToken(YQLParserANSI, 0) } func (s *Keyword_compatContext) ARRAY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserARRAY, 0) + return s.GetToken(YQLParserARRAY, 0) } func (s *Keyword_compatContext) ASC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASC, 0) + return s.GetToken(YQLParserASC, 0) } func (s *Keyword_compatContext) ASYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserASYNC, 0) + return s.GetToken(YQLParserASYNC, 0) } func (s *Keyword_compatContext) AT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAT, 0) + return s.GetToken(YQLParserAT, 0) } func (s *Keyword_compatContext) ATTACH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserATTACH, 0) + return s.GetToken(YQLParserATTACH, 0) } func (s *Keyword_compatContext) ATTRIBUTES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserATTRIBUTES, 0) + return s.GetToken(YQLParserATTRIBUTES, 0) } func (s *Keyword_compatContext) AUTOINCREMENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserAUTOINCREMENT, 0) + return s.GetToken(YQLParserAUTOINCREMENT, 0) } func (s *Keyword_compatContext) BACKUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBACKUP, 0) + return s.GetToken(YQLParserBACKUP, 0) } func (s *Keyword_compatContext) BEFORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBEFORE, 0) + return s.GetToken(YQLParserBEFORE, 0) } func (s *Keyword_compatContext) BEGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBEGIN, 0) + return s.GetToken(YQLParserBEGIN, 0) } func (s *Keyword_compatContext) BERNOULLI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBERNOULLI, 0) + return s.GetToken(YQLParserBERNOULLI, 0) } func (s *Keyword_compatContext) BY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserBY, 0) + return s.GetToken(YQLParserBY, 0) } func (s *Keyword_compatContext) CASCADE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCASCADE, 0) + return s.GetToken(YQLParserCASCADE, 0) } func (s *Keyword_compatContext) CHANGEFEED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCHANGEFEED, 0) + return s.GetToken(YQLParserCHANGEFEED, 0) } func (s *Keyword_compatContext) CHECK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCHECK, 0) + return s.GetToken(YQLParserCHECK, 0) } func (s *Keyword_compatContext) CLASSIFIER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCLASSIFIER, 0) + return s.GetToken(YQLParserCLASSIFIER, 0) } func (s *Keyword_compatContext) COLLATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLLATE, 0) + return s.GetToken(YQLParserCOLLATE, 0) } func (s *Keyword_compatContext) COLLECTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOLLECTION, 0) + return s.GetToken(YQLParserCOLLECTION, 0) } func (s *Keyword_compatContext) COMMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOMMIT, 0) + return s.GetToken(YQLParserCOMMIT, 0) } func (s *Keyword_compatContext) CONDITIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONDITIONAL, 0) + return s.GetToken(YQLParserCONDITIONAL, 0) } func (s *Keyword_compatContext) CONFLICT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONFLICT, 0) + return s.GetToken(YQLParserCONFLICT, 0) } func (s *Keyword_compatContext) CONNECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONNECT, 0) + return s.GetToken(YQLParserCONNECT, 0) } func (s *Keyword_compatContext) CONSTRAINT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONSTRAINT, 0) + return s.GetToken(YQLParserCONSTRAINT, 0) } func (s *Keyword_compatContext) CONSUMER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCONSUMER, 0) + return s.GetToken(YQLParserCONSUMER, 0) } func (s *Keyword_compatContext) COVER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCOVER, 0) + return s.GetToken(YQLParserCOVER, 0) } func (s *Keyword_compatContext) CREATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCREATE, 0) + return s.GetToken(YQLParserCREATE, 0) } func (s *Keyword_compatContext) CROSS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCROSS, 0) + return s.GetToken(YQLParserCROSS, 0) } func (s *Keyword_compatContext) CURRENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCURRENT, 0) + return s.GetToken(YQLParserCURRENT, 0) } func (s *Keyword_compatContext) DATA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATA, 0) + return s.GetToken(YQLParserDATA, 0) } func (s *Keyword_compatContext) DATABASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDATABASE, 0) + return s.GetToken(YQLParserDATABASE, 0) } func (s *Keyword_compatContext) DECIMAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDECIMAL, 0) + return s.GetToken(YQLParserDECIMAL, 0) } func (s *Keyword_compatContext) DECLARE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDECLARE, 0) + return s.GetToken(YQLParserDECLARE, 0) } func (s *Keyword_compatContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFAULT, 0) + return s.GetToken(YQLParserDEFAULT, 0) } func (s *Keyword_compatContext) DEFERRABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFERRABLE, 0) + return s.GetToken(YQLParserDEFERRABLE, 0) } func (s *Keyword_compatContext) DEFERRED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFERRED, 0) + return s.GetToken(YQLParserDEFERRED, 0) } func (s *Keyword_compatContext) DEFINE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDEFINE, 0) + return s.GetToken(YQLParserDEFINE, 0) } func (s *Keyword_compatContext) DELETE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDELETE, 0) + return s.GetToken(YQLParserDELETE, 0) } func (s *Keyword_compatContext) DESC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDESC, 0) + return s.GetToken(YQLParserDESC, 0) } func (s *Keyword_compatContext) DESCRIBE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDESCRIBE, 0) + return s.GetToken(YQLParserDESCRIBE, 0) } func (s *Keyword_compatContext) DETACH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDETACH, 0) + return s.GetToken(YQLParserDETACH, 0) } func (s *Keyword_compatContext) DIRECTORY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDIRECTORY, 0) + return s.GetToken(YQLParserDIRECTORY, 0) } func (s *Keyword_compatContext) DISABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISABLE, 0) + return s.GetToken(YQLParserDISABLE, 0) } func (s *Keyword_compatContext) DISCARD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDISCARD, 0) + return s.GetToken(YQLParserDISCARD, 0) } func (s *Keyword_compatContext) DO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDO, 0) + return s.GetToken(YQLParserDO, 0) } func (s *Keyword_compatContext) DROP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDROP, 0) + return s.GetToken(YQLParserDROP, 0) } func (s *Keyword_compatContext) EACH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEACH, 0) + return s.GetToken(YQLParserEACH, 0) } func (s *Keyword_compatContext) ELSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserELSE, 0) + return s.GetToken(YQLParserELSE, 0) } func (s *Keyword_compatContext) EMPTY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEMPTY, 0) + return s.GetToken(YQLParserEMPTY, 0) } func (s *Keyword_compatContext) ENCRYPTED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserENCRYPTED, 0) + return s.GetToken(YQLParserENCRYPTED, 0) } func (s *Keyword_compatContext) END() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEND, 0) + return s.GetToken(YQLParserEND, 0) } func (s *Keyword_compatContext) ERROR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserERROR, 0) + return s.GetToken(YQLParserERROR, 0) } func (s *Keyword_compatContext) ESCAPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserESCAPE, 0) + return s.GetToken(YQLParserESCAPE, 0) } func (s *Keyword_compatContext) EVALUATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEVALUATE, 0) + return s.GetToken(YQLParserEVALUATE, 0) } func (s *Keyword_compatContext) EXCLUDE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCLUDE, 0) + return s.GetToken(YQLParserEXCLUDE, 0) } func (s *Keyword_compatContext) EXCLUSION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCLUSION, 0) + return s.GetToken(YQLParserEXCLUSION, 0) } func (s *Keyword_compatContext) EXCLUSIVE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXCLUSIVE, 0) + return s.GetToken(YQLParserEXCLUSIVE, 0) } func (s *Keyword_compatContext) EXPLAIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXPLAIN, 0) + return s.GetToken(YQLParserEXPLAIN, 0) } func (s *Keyword_compatContext) EXPORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXPORT, 0) + return s.GetToken(YQLParserEXPORT, 0) } func (s *Keyword_compatContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserEXTERNAL, 0) + return s.GetToken(YQLParserEXTERNAL, 0) } func (s *Keyword_compatContext) FAIL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFAIL, 0) + return s.GetToken(YQLParserFAIL, 0) } func (s *Keyword_compatContext) FAMILY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFAMILY, 0) + return s.GetToken(YQLParserFAMILY, 0) } func (s *Keyword_compatContext) FILTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFILTER, 0) + return s.GetToken(YQLParserFILTER, 0) } func (s *Keyword_compatContext) FIRST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFIRST, 0) + return s.GetToken(YQLParserFIRST, 0) } func (s *Keyword_compatContext) FLATTEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFLATTEN, 0) + return s.GetToken(YQLParserFLATTEN, 0) } func (s *Keyword_compatContext) FOLLOWING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOLLOWING, 0) + return s.GetToken(YQLParserFOLLOWING, 0) } func (s *Keyword_compatContext) FOR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOR, 0) + return s.GetToken(YQLParserFOR, 0) } func (s *Keyword_compatContext) FOREIGN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFOREIGN, 0) + return s.GetToken(YQLParserFOREIGN, 0) } func (s *Keyword_compatContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFUNCTION, 0) + return s.GetToken(YQLParserFUNCTION, 0) } func (s *Keyword_compatContext) GLOB() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGLOB, 0) + return s.GetToken(YQLParserGLOB, 0) } func (s *Keyword_compatContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGLOBAL, 0) + return s.GetToken(YQLParserGLOBAL, 0) } func (s *Keyword_compatContext) GRANT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGRANT, 0) + return s.GetToken(YQLParserGRANT, 0) } func (s *Keyword_compatContext) GROUP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUP, 0) + return s.GetToken(YQLParserGROUP, 0) } func (s *Keyword_compatContext) GROUPING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserGROUPING, 0) + return s.GetToken(YQLParserGROUPING, 0) } func (s *Keyword_compatContext) HASH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserHASH, 0) + return s.GetToken(YQLParserHASH, 0) } func (s *Keyword_compatContext) IF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIF, 0) + return s.GetToken(YQLParserIF, 0) } func (s *Keyword_compatContext) IGNORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIGNORE, 0) + return s.GetToken(YQLParserIGNORE, 0) } func (s *Keyword_compatContext) ILIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserILIKE, 0) + return s.GetToken(YQLParserILIKE, 0) } func (s *Keyword_compatContext) IMMEDIATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIMMEDIATE, 0) + return s.GetToken(YQLParserIMMEDIATE, 0) } func (s *Keyword_compatContext) IMPORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIMPORT, 0) + return s.GetToken(YQLParserIMPORT, 0) } func (s *Keyword_compatContext) IN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIN, 0) + return s.GetToken(YQLParserIN, 0) } func (s *Keyword_compatContext) INCREMENT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINCREMENT, 0) + return s.GetToken(YQLParserINCREMENT, 0) } func (s *Keyword_compatContext) INCREMENTAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINCREMENTAL, 0) + return s.GetToken(YQLParserINCREMENTAL, 0) } func (s *Keyword_compatContext) INDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEX, 0) + return s.GetToken(YQLParserINDEX, 0) } func (s *Keyword_compatContext) INDEXED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINDEXED, 0) + return s.GetToken(YQLParserINDEXED, 0) } func (s *Keyword_compatContext) INHERITS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINHERITS, 0) + return s.GetToken(YQLParserINHERITS, 0) } func (s *Keyword_compatContext) INITIAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINITIAL, 0) + return s.GetToken(YQLParserINITIAL, 0) } func (s *Keyword_compatContext) INITIALLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINITIALLY, 0) + return s.GetToken(YQLParserINITIALLY, 0) } func (s *Keyword_compatContext) INNER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINNER, 0) + return s.GetToken(YQLParserINNER, 0) } func (s *Keyword_compatContext) INSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINSERT, 0) + return s.GetToken(YQLParserINSERT, 0) } func (s *Keyword_compatContext) INSTEAD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINSTEAD, 0) + return s.GetToken(YQLParserINSTEAD, 0) } func (s *Keyword_compatContext) INTO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINTO, 0) + return s.GetToken(YQLParserINTO, 0) } func (s *Keyword_compatContext) IS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserIS, 0) + return s.GetToken(YQLParserIS, 0) } func (s *Keyword_compatContext) ISNULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserISNULL, 0) + return s.GetToken(YQLParserISNULL, 0) } func (s *Keyword_compatContext) JOIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserJOIN, 0) + return s.GetToken(YQLParserJOIN, 0) } func (s *Keyword_compatContext) KEY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserKEY, 0) + return s.GetToken(YQLParserKEY, 0) } func (s *Keyword_compatContext) LAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLAST, 0) + return s.GetToken(YQLParserLAST, 0) } func (s *Keyword_compatContext) LEFT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLEFT, 0) + return s.GetToken(YQLParserLEFT, 0) } func (s *Keyword_compatContext) LEGACY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLEGACY, 0) + return s.GetToken(YQLParserLEGACY, 0) } func (s *Keyword_compatContext) LIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIKE, 0) + return s.GetToken(YQLParserLIKE, 0) } func (s *Keyword_compatContext) LOCAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLOCAL, 0) + return s.GetToken(YQLParserLOCAL, 0) } func (s *Keyword_compatContext) LOGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLOGIN, 0) + return s.GetToken(YQLParserLOGIN, 0) } func (s *Keyword_compatContext) MANAGE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMANAGE, 0) + return s.GetToken(YQLParserMANAGE, 0) } func (s *Keyword_compatContext) MATCH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH, 0) + return s.GetToken(YQLParserMATCH, 0) } func (s *Keyword_compatContext) MATCHES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCHES, 0) + return s.GetToken(YQLParserMATCHES, 0) } func (s *Keyword_compatContext) MATCH_RECOGNIZE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMATCH_RECOGNIZE, 0) + return s.GetToken(YQLParserMATCH_RECOGNIZE, 0) } func (s *Keyword_compatContext) MEASURES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMEASURES, 0) + return s.GetToken(YQLParserMEASURES, 0) } func (s *Keyword_compatContext) MICROSECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMICROSECONDS, 0) + return s.GetToken(YQLParserMICROSECONDS, 0) } func (s *Keyword_compatContext) MILLISECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMILLISECONDS, 0) + return s.GetToken(YQLParserMILLISECONDS, 0) } func (s *Keyword_compatContext) MODIFY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserMODIFY, 0) + return s.GetToken(YQLParserMODIFY, 0) } func (s *Keyword_compatContext) NANOSECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNANOSECONDS, 0) + return s.GetToken(YQLParserNANOSECONDS, 0) } func (s *Keyword_compatContext) NATURAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNATURAL, 0) + return s.GetToken(YQLParserNATURAL, 0) } func (s *Keyword_compatContext) NEXT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNEXT, 0) + return s.GetToken(YQLParserNEXT, 0) } func (s *Keyword_compatContext) NO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNO, 0) + return s.GetToken(YQLParserNO, 0) } func (s *Keyword_compatContext) NOLOGIN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOLOGIN, 0) + return s.GetToken(YQLParserNOLOGIN, 0) } func (s *Keyword_compatContext) NOTNULL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNOTNULL, 0) + return s.GetToken(YQLParserNOTNULL, 0) } func (s *Keyword_compatContext) NULLS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserNULLS, 0) + return s.GetToken(YQLParserNULLS, 0) } func (s *Keyword_compatContext) OBJECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOBJECT, 0) + return s.GetToken(YQLParserOBJECT, 0) } func (s *Keyword_compatContext) OF() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOF, 0) + return s.GetToken(YQLParserOF, 0) } func (s *Keyword_compatContext) OFFSET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOFFSET, 0) + return s.GetToken(YQLParserOFFSET, 0) } func (s *Keyword_compatContext) OMIT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOMIT, 0) + return s.GetToken(YQLParserOMIT, 0) } func (s *Keyword_compatContext) ON() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserON, 0) + return s.GetToken(YQLParserON, 0) } func (s *Keyword_compatContext) ONE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserONE, 0) + return s.GetToken(YQLParserONE, 0) } func (s *Keyword_compatContext) ONLY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserONLY, 0) + return s.GetToken(YQLParserONLY, 0) } func (s *Keyword_compatContext) OPTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOPTION, 0) + return s.GetToken(YQLParserOPTION, 0) } func (s *Keyword_compatContext) OR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOR, 0) + return s.GetToken(YQLParserOR, 0) } func (s *Keyword_compatContext) ORDER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserORDER, 0) + return s.GetToken(YQLParserORDER, 0) } func (s *Keyword_compatContext) OTHERS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOTHERS, 0) + return s.GetToken(YQLParserOTHERS, 0) } func (s *Keyword_compatContext) OUTER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOUTER, 0) + return s.GetToken(YQLParserOUTER, 0) } func (s *Keyword_compatContext) OVER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOVER, 0) + return s.GetToken(YQLParserOVER, 0) } func (s *Keyword_compatContext) PARALLEL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARALLEL, 0) + return s.GetToken(YQLParserPARALLEL, 0) } func (s *Keyword_compatContext) PARTITION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPARTITION, 0) + return s.GetToken(YQLParserPARTITION, 0) } func (s *Keyword_compatContext) PASSING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPASSING, 0) + return s.GetToken(YQLParserPASSING, 0) } func (s *Keyword_compatContext) PASSWORD() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPASSWORD, 0) + return s.GetToken(YQLParserPASSWORD, 0) } func (s *Keyword_compatContext) PAST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPAST, 0) + return s.GetToken(YQLParserPAST, 0) } func (s *Keyword_compatContext) PATTERN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPATTERN, 0) + return s.GetToken(YQLParserPATTERN, 0) } func (s *Keyword_compatContext) PER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPER, 0) + return s.GetToken(YQLParserPER, 0) } func (s *Keyword_compatContext) PERMUTE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPERMUTE, 0) + return s.GetToken(YQLParserPERMUTE, 0) } func (s *Keyword_compatContext) PLAN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPLAN, 0) + return s.GetToken(YQLParserPLAN, 0) } func (s *Keyword_compatContext) POOL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPOOL, 0) + return s.GetToken(YQLParserPOOL, 0) } func (s *Keyword_compatContext) PRAGMA() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRAGMA, 0) + return s.GetToken(YQLParserPRAGMA, 0) } func (s *Keyword_compatContext) PRECEDING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRECEDING, 0) + return s.GetToken(YQLParserPRECEDING, 0) } func (s *Keyword_compatContext) PRESORT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRESORT, 0) + return s.GetToken(YQLParserPRESORT, 0) } func (s *Keyword_compatContext) PRIMARY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRIMARY, 0) + return s.GetToken(YQLParserPRIMARY, 0) } func (s *Keyword_compatContext) PRIVILEGES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserPRIVILEGES, 0) + return s.GetToken(YQLParserPRIVILEGES, 0) } func (s *Keyword_compatContext) QUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUERY, 0) + return s.GetToken(YQLParserQUERY, 0) } func (s *Keyword_compatContext) QUEUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserQUEUE, 0) + return s.GetToken(YQLParserQUEUE, 0) } func (s *Keyword_compatContext) RAISE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRAISE, 0) + return s.GetToken(YQLParserRAISE, 0) } func (s *Keyword_compatContext) REFERENCES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREFERENCES, 0) + return s.GetToken(YQLParserREFERENCES, 0) } func (s *Keyword_compatContext) REGEXP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREGEXP, 0) + return s.GetToken(YQLParserREGEXP, 0) } func (s *Keyword_compatContext) REINDEX() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREINDEX, 0) + return s.GetToken(YQLParserREINDEX, 0) } func (s *Keyword_compatContext) RELEASE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRELEASE, 0) + return s.GetToken(YQLParserRELEASE, 0) } func (s *Keyword_compatContext) REMOVE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREMOVE, 0) + return s.GetToken(YQLParserREMOVE, 0) } func (s *Keyword_compatContext) RENAME() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRENAME, 0) + return s.GetToken(YQLParserRENAME, 0) } func (s *Keyword_compatContext) REPLACE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLACE, 0) + return s.GetToken(YQLParserREPLACE, 0) } func (s *Keyword_compatContext) REPLICATION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREPLICATION, 0) + return s.GetToken(YQLParserREPLICATION, 0) } func (s *Keyword_compatContext) RESET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESET, 0) + return s.GetToken(YQLParserRESET, 0) } func (s *Keyword_compatContext) RESPECT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESPECT, 0) + return s.GetToken(YQLParserRESPECT, 0) } func (s *Keyword_compatContext) RESTART() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTART, 0) + return s.GetToken(YQLParserRESTART, 0) } func (s *Keyword_compatContext) RESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTORE, 0) + return s.GetToken(YQLParserRESTORE, 0) } func (s *Keyword_compatContext) RESTRICT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESTRICT, 0) + return s.GetToken(YQLParserRESTRICT, 0) } func (s *Keyword_compatContext) RESULT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESULT, 0) + return s.GetToken(YQLParserRESULT, 0) } func (s *Keyword_compatContext) REVERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREVERT, 0) + return s.GetToken(YQLParserREVERT, 0) } func (s *Keyword_compatContext) REVOKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREVOKE, 0) + return s.GetToken(YQLParserREVOKE, 0) } func (s *Keyword_compatContext) RIGHT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRIGHT, 0) + return s.GetToken(YQLParserRIGHT, 0) } func (s *Keyword_compatContext) RLIKE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRLIKE, 0) + return s.GetToken(YQLParserRLIKE, 0) } func (s *Keyword_compatContext) ROLLBACK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROLLBACK, 0) + return s.GetToken(YQLParserROLLBACK, 0) } func (s *Keyword_compatContext) ROW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserROW, 0) + return s.GetToken(YQLParserROW, 0) } func (s *Keyword_compatContext) SAMPLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSAMPLE, 0) + return s.GetToken(YQLParserSAMPLE, 0) } func (s *Keyword_compatContext) SAVEPOINT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSAVEPOINT, 0) + return s.GetToken(YQLParserSAVEPOINT, 0) } func (s *Keyword_compatContext) SECONDS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSECONDS, 0) + return s.GetToken(YQLParserSECONDS, 0) } func (s *Keyword_compatContext) SEEK() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEEK, 0) + return s.GetToken(YQLParserSEEK, 0) } func (s *Keyword_compatContext) SEMI() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEMI, 0) + return s.GetToken(YQLParserSEMI, 0) } func (s *Keyword_compatContext) SETS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSETS, 0) + return s.GetToken(YQLParserSETS, 0) } func (s *Keyword_compatContext) SHOW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSHOW, 0) + return s.GetToken(YQLParserSHOW, 0) } func (s *Keyword_compatContext) TSKIP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTSKIP, 0) + return s.GetToken(YQLParserTSKIP, 0) } func (s *Keyword_compatContext) SEQUENCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSEQUENCE, 0) + return s.GetToken(YQLParserSEQUENCE, 0) } func (s *Keyword_compatContext) SOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSOURCE, 0) + return s.GetToken(YQLParserSOURCE, 0) } func (s *Keyword_compatContext) START() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTART, 0) + return s.GetToken(YQLParserSTART, 0) } func (s *Keyword_compatContext) SUBQUERY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSUBQUERY, 0) + return s.GetToken(YQLParserSUBQUERY, 0) } func (s *Keyword_compatContext) SUBSET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSUBSET, 0) + return s.GetToken(YQLParserSUBSET, 0) } func (s *Keyword_compatContext) SYMBOLS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYMBOLS, 0) + return s.GetToken(YQLParserSYMBOLS, 0) } func (s *Keyword_compatContext) SYNC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYNC, 0) + return s.GetToken(YQLParserSYNC, 0) } func (s *Keyword_compatContext) SYSTEM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSYSTEM, 0) + return s.GetToken(YQLParserSYSTEM, 0) } func (s *Keyword_compatContext) TABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLE, 0) + return s.GetToken(YQLParserTABLE, 0) } func (s *Keyword_compatContext) TABLES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLES, 0) + return s.GetToken(YQLParserTABLES, 0) } func (s *Keyword_compatContext) TABLESAMPLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESAMPLE, 0) + return s.GetToken(YQLParserTABLESAMPLE, 0) } func (s *Keyword_compatContext) TABLESTORE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTABLESTORE, 0) + return s.GetToken(YQLParserTABLESTORE, 0) } func (s *Keyword_compatContext) TEMP() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTEMP, 0) + return s.GetToken(YQLParserTEMP, 0) } func (s *Keyword_compatContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTEMPORARY, 0) + return s.GetToken(YQLParserTEMPORARY, 0) } func (s *Keyword_compatContext) THEN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTHEN, 0) + return s.GetToken(YQLParserTHEN, 0) } func (s *Keyword_compatContext) TIES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTIES, 0) + return s.GetToken(YQLParserTIES, 0) } func (s *Keyword_compatContext) TO() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTO, 0) + return s.GetToken(YQLParserTO, 0) } func (s *Keyword_compatContext) TOPIC() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTOPIC, 0) + return s.GetToken(YQLParserTOPIC, 0) } func (s *Keyword_compatContext) TRANSACTION() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTRANSACTION, 0) + return s.GetToken(YQLParserTRANSACTION, 0) } func (s *Keyword_compatContext) TRIGGER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTRIGGER, 0) + return s.GetToken(YQLParserTRIGGER, 0) } func (s *Keyword_compatContext) TYPE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTYPE, 0) + return s.GetToken(YQLParserTYPE, 0) } func (s *Keyword_compatContext) UNCONDITIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNCONDITIONAL, 0) + return s.GetToken(YQLParserUNCONDITIONAL, 0) } func (s *Keyword_compatContext) UNIQUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNIQUE, 0) + return s.GetToken(YQLParserUNIQUE, 0) } func (s *Keyword_compatContext) UNKNOWN() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNKNOWN, 0) + return s.GetToken(YQLParserUNKNOWN, 0) } func (s *Keyword_compatContext) UNMATCHED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUNMATCHED, 0) + return s.GetToken(YQLParserUNMATCHED, 0) } func (s *Keyword_compatContext) UPDATE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPDATE, 0) + return s.GetToken(YQLParserUPDATE, 0) } func (s *Keyword_compatContext) UPSERT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUPSERT, 0) + return s.GetToken(YQLParserUPSERT, 0) } func (s *Keyword_compatContext) USE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSE, 0) + return s.GetToken(YQLParserUSE, 0) } func (s *Keyword_compatContext) USER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSER, 0) + return s.GetToken(YQLParserUSER, 0) } func (s *Keyword_compatContext) USING() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserUSING, 0) + return s.GetToken(YQLParserUSING, 0) } func (s *Keyword_compatContext) VACUUM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVACUUM, 0) + return s.GetToken(YQLParserVACUUM, 0) } func (s *Keyword_compatContext) VALUES() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVALUES, 0) + return s.GetToken(YQLParserVALUES, 0) } func (s *Keyword_compatContext) VIEW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIEW, 0) + return s.GetToken(YQLParserVIEW, 0) } func (s *Keyword_compatContext) VIRTUAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVIRTUAL, 0) + return s.GetToken(YQLParserVIRTUAL, 0) } func (s *Keyword_compatContext) WITH() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWITH, 0) + return s.GetToken(YQLParserWITH, 0) } func (s *Keyword_compatContext) WRAPPER() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserWRAPPER, 0) + return s.GetToken(YQLParserWRAPPER, 0) } func (s *Keyword_compatContext) XOR() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserXOR, 0) + return s.GetToken(YQLParserXOR, 0) } func (s *Keyword_compatContext) GetRuleContext() antlr.RuleContext { @@ -89496,13 +89496,13 @@ func (s *Keyword_compatContext) ToStringTree(ruleNames []string, recog antlr.Rec func (s *Keyword_compatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterKeyword_compat(s) } } func (s *Keyword_compatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitKeyword_compat(s) } } @@ -89510,9 +89510,9 @@ func (s *Keyword_compatContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Keyword_compat() (localctx IKeyword_compatContext) { +func (p *YQLParser) Keyword_compat() (localctx IKeyword_compatContext) { localctx = NewKeyword_compatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 856, YQLv1Antlr4ParserRULE_keyword_compat) + p.EnterRule(localctx, 856, YQLParserRULE_keyword_compat) var _la int p.EnterOuterAlt(localctx, 1) @@ -89577,13 +89577,13 @@ type Type_idContext struct { func NewEmptyType_idContext() *Type_idContext { var p = new(Type_idContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_id + p.RuleIndex = YQLParserRULE_type_id return p } func InitEmptyType_idContext(p *Type_idContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_type_id + p.RuleIndex = YQLParserRULE_type_id } func (*Type_idContext) IsType_idContext() {} @@ -89594,7 +89594,7 @@ func NewType_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_type_id + p.RuleIndex = YQLParserRULE_type_id return p } @@ -89602,51 +89602,51 @@ func NewType_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *Type_idContext) GetParser() antlr.Parser { return s.parser } func (s *Type_idContext) OPTIONAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserOPTIONAL, 0) + return s.GetToken(YQLParserOPTIONAL, 0) } func (s *Type_idContext) TUPLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTUPLE, 0) + return s.GetToken(YQLParserTUPLE, 0) } func (s *Type_idContext) STRUCT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSTRUCT, 0) + return s.GetToken(YQLParserSTRUCT, 0) } func (s *Type_idContext) VARIANT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserVARIANT, 0) + return s.GetToken(YQLParserVARIANT, 0) } func (s *Type_idContext) LIST() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserLIST, 0) + return s.GetToken(YQLParserLIST, 0) } func (s *Type_idContext) FLOW() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFLOW, 0) + return s.GetToken(YQLParserFLOW, 0) } func (s *Type_idContext) DICT() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDICT, 0) + return s.GetToken(YQLParserDICT, 0) } func (s *Type_idContext) SET() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserSET, 0) + return s.GetToken(YQLParserSET, 0) } func (s *Type_idContext) ENUM() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserENUM, 0) + return s.GetToken(YQLParserENUM, 0) } func (s *Type_idContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserRESOURCE, 0) + return s.GetToken(YQLParserRESOURCE, 0) } func (s *Type_idContext) TAGGED() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTAGGED, 0) + return s.GetToken(YQLParserTAGGED, 0) } func (s *Type_idContext) CALLABLE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserCALLABLE, 0) + return s.GetToken(YQLParserCALLABLE, 0) } func (s *Type_idContext) GetRuleContext() antlr.RuleContext { @@ -89659,13 +89659,13 @@ func (s *Type_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *Type_idContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterType_id(s) } } func (s *Type_idContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitType_id(s) } } @@ -89673,9 +89673,9 @@ func (s *Type_idContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Type_id() (localctx IType_idContext) { +func (p *YQLParser) Type_id() (localctx IType_idContext) { localctx = NewType_idContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 858, YQLv1Antlr4ParserRULE_type_id) + p.EnterRule(localctx, 858, YQLParserRULE_type_id) var _la int p.EnterOuterAlt(localctx, 1) @@ -89683,7 +89683,7 @@ func (p *YQLv1Antlr4Parser) Type_id() (localctx IType_idContext) { p.SetState(4559) _la = p.GetTokenStream().LA(1) - if !(((int64((_la - 67)) & ^0x3f) == 0 && ((int64(1) << (_la - 67)) & 1126037345796097) != 0) || _la == YQLv1Antlr4ParserFLOW || _la == YQLv1Antlr4ParserLIST || ((int64((_la - 210)) & ^0x3f) == 0 && ((int64(1) << (_la - 210)) & 1152921642045800449) != 0) || ((int64((_la - 278)) & ^0x3f) == 0 && ((int64(1) << (_la - 278)) & 68721575937) != 0)) { + if !(((int64((_la - 67)) & ^0x3f) == 0 && ((int64(1) << (_la - 67)) & 1126037345796097) != 0) || _la == YQLParserFLOW || _la == YQLParserLIST || ((int64((_la - 210)) & ^0x3f) == 0 && ((int64(1) << (_la - 210)) & 1152921642045800449) != 0) || ((int64((_la - 278)) & ^0x3f) == 0 && ((int64(1) << (_la - 278)) & 68721575937) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -89730,13 +89730,13 @@ type Bool_valueContext struct { func NewEmptyBool_valueContext() *Bool_valueContext { var p = new(Bool_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bool_value + p.RuleIndex = YQLParserRULE_bool_value return p } func InitEmptyBool_valueContext(p *Bool_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_bool_value + p.RuleIndex = YQLParserRULE_bool_value } func (*Bool_valueContext) IsBool_valueContext() {} @@ -89747,7 +89747,7 @@ func NewBool_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_bool_value + p.RuleIndex = YQLParserRULE_bool_value return p } @@ -89755,11 +89755,11 @@ func NewBool_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *Bool_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Bool_valueContext) TRUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserTRUE, 0) + return s.GetToken(YQLParserTRUE, 0) } func (s *Bool_valueContext) FALSE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserFALSE, 0) + return s.GetToken(YQLParserFALSE, 0) } func (s *Bool_valueContext) GetRuleContext() antlr.RuleContext { @@ -89772,13 +89772,13 @@ func (s *Bool_valueContext) ToStringTree(ruleNames []string, recog antlr.Recogni func (s *Bool_valueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterBool_value(s) } } func (s *Bool_valueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitBool_value(s) } } @@ -89786,9 +89786,9 @@ func (s *Bool_valueContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Bool_value() (localctx IBool_valueContext) { +func (p *YQLParser) Bool_value() (localctx IBool_valueContext) { localctx = NewBool_valueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 860, YQLv1Antlr4ParserRULE_bool_value) + p.EnterRule(localctx, 860, YQLParserRULE_bool_value) var _la int p.EnterOuterAlt(localctx, 1) @@ -89796,7 +89796,7 @@ func (p *YQLv1Antlr4Parser) Bool_value() (localctx IBool_valueContext) { p.SetState(4561) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserFALSE || _la == YQLv1Antlr4ParserTRUE) { + if !(_la == YQLParserFALSE || _la == YQLParserTRUE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -89842,13 +89842,13 @@ type RealContext struct { func NewEmptyRealContext() *RealContext { var p = new(RealContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_real + p.RuleIndex = YQLParserRULE_real return p } func InitEmptyRealContext(p *RealContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_real + p.RuleIndex = YQLParserRULE_real } func (*RealContext) IsRealContext() {} @@ -89859,7 +89859,7 @@ func NewRealContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokin antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_real + p.RuleIndex = YQLParserRULE_real return p } @@ -89867,7 +89867,7 @@ func NewRealContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokin func (s *RealContext) GetParser() antlr.Parser { return s.parser } func (s *RealContext) REAL() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserREAL, 0) + return s.GetToken(YQLParserREAL, 0) } func (s *RealContext) GetRuleContext() antlr.RuleContext { @@ -89880,13 +89880,13 @@ func (s *RealContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) s func (s *RealContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterReal(s) } } func (s *RealContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitReal(s) } } @@ -89894,13 +89894,13 @@ func (s *RealContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Real_() (localctx IRealContext) { +func (p *YQLParser) Real_() (localctx IRealContext) { localctx = NewRealContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 862, YQLv1Antlr4ParserRULE_real) + p.EnterRule(localctx, 862, YQLParserRULE_real) p.EnterOuterAlt(localctx, 1) { p.SetState(4563) - p.Match(YQLv1Antlr4ParserREAL) + p.Match(YQLParserREAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89946,13 +89946,13 @@ type IntegerContext struct { func NewEmptyIntegerContext() *IntegerContext { var p = new(IntegerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_integer + p.RuleIndex = YQLParserRULE_integer return p } func InitEmptyIntegerContext(p *IntegerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = YQLv1Antlr4ParserRULE_integer + p.RuleIndex = YQLParserRULE_integer } func (*IntegerContext) IsIntegerContext() {} @@ -89963,7 +89963,7 @@ func NewIntegerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = YQLv1Antlr4ParserRULE_integer + p.RuleIndex = YQLParserRULE_integer return p } @@ -89971,11 +89971,11 @@ func NewIntegerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *IntegerContext) GetParser() antlr.Parser { return s.parser } func (s *IntegerContext) DIGITS() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserDIGITS, 0) + return s.GetToken(YQLParserDIGITS, 0) } func (s *IntegerContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(YQLv1Antlr4ParserINTEGER_VALUE, 0) + return s.GetToken(YQLParserINTEGER_VALUE, 0) } func (s *IntegerContext) GetRuleContext() antlr.RuleContext { @@ -89988,13 +89988,13 @@ func (s *IntegerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer func (s *IntegerContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.EnterInteger(s) } } func (s *IntegerContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(YQLv1Antlr4Listener); ok { + if listenerT, ok := listener.(YQLListener); ok { listenerT.ExitInteger(s) } } @@ -90002,9 +90002,9 @@ func (s *IntegerContext) ExitRule(listener antlr.ParseTreeListener) { -func (p *YQLv1Antlr4Parser) Integer() (localctx IIntegerContext) { +func (p *YQLParser) Integer() (localctx IIntegerContext) { localctx = NewIntegerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 864, YQLv1Antlr4ParserRULE_integer) + p.EnterRule(localctx, 864, YQLParserRULE_integer) var _la int p.EnterOuterAlt(localctx, 1) @@ -90012,7 +90012,7 @@ func (p *YQLv1Antlr4Parser) Integer() (localctx IIntegerContext) { p.SetState(4565) _la = p.GetTokenStream().LA(1) - if !(_la == YQLv1Antlr4ParserDIGITS || _la == YQLv1Antlr4ParserINTEGER_VALUE) { + if !(_la == YQLParserDIGITS || _la == YQLParserINTEGER_VALUE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) diff --git a/parser/yql/yqlv1antlr4_base_listener.go b/parser/yql/yqlv1antlr4_base_listener.go deleted file mode 100644 index 68b92e084..000000000 --- a/parser/yql/yqlv1antlr4_base_listener.go +++ /dev/null @@ -1,2619 +0,0 @@ -// Code generated from YQLv1Antlr4.g4 by ANTLR 4.13.2. DO NOT EDIT. - -package yql // YQLv1Antlr4 -import "github.com/antlr4-go/antlr/v4" - -// BaseYQLv1Antlr4Listener is a complete listener for a parse tree produced by YQLv1Antlr4Parser. -type BaseYQLv1Antlr4Listener struct{} - -var _ YQLv1Antlr4Listener = &BaseYQLv1Antlr4Listener{} - -// VisitTerminal is called when a terminal node is visited. -func (s *BaseYQLv1Antlr4Listener) VisitTerminal(node antlr.TerminalNode) {} - -// VisitErrorNode is called when an error node is visited. -func (s *BaseYQLv1Antlr4Listener) VisitErrorNode(node antlr.ErrorNode) {} - -// EnterEveryRule is called when any rule is entered. -func (s *BaseYQLv1Antlr4Listener) EnterEveryRule(ctx antlr.ParserRuleContext) {} - -// ExitEveryRule is called when any rule is exited. -func (s *BaseYQLv1Antlr4Listener) ExitEveryRule(ctx antlr.ParserRuleContext) {} - -// EnterSql_query is called when production sql_query is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSql_query(ctx *Sql_queryContext) {} - -// ExitSql_query is called when production sql_query is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSql_query(ctx *Sql_queryContext) {} - -// EnterSql_stmt_list is called when production sql_stmt_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSql_stmt_list(ctx *Sql_stmt_listContext) {} - -// ExitSql_stmt_list is called when production sql_stmt_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSql_stmt_list(ctx *Sql_stmt_listContext) {} - -// EnterAnsi_sql_stmt_list is called when production ansi_sql_stmt_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAnsi_sql_stmt_list(ctx *Ansi_sql_stmt_listContext) {} - -// ExitAnsi_sql_stmt_list is called when production ansi_sql_stmt_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAnsi_sql_stmt_list(ctx *Ansi_sql_stmt_listContext) {} - -// EnterLambda_body is called when production lambda_body is entered. -func (s *BaseYQLv1Antlr4Listener) EnterLambda_body(ctx *Lambda_bodyContext) {} - -// ExitLambda_body is called when production lambda_body is exited. -func (s *BaseYQLv1Antlr4Listener) ExitLambda_body(ctx *Lambda_bodyContext) {} - -// EnterLambda_stmt is called when production lambda_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterLambda_stmt(ctx *Lambda_stmtContext) {} - -// ExitLambda_stmt is called when production lambda_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitLambda_stmt(ctx *Lambda_stmtContext) {} - -// EnterSql_stmt is called when production sql_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSql_stmt(ctx *Sql_stmtContext) {} - -// ExitSql_stmt is called when production sql_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSql_stmt(ctx *Sql_stmtContext) {} - -// EnterSql_stmt_core is called when production sql_stmt_core is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSql_stmt_core(ctx *Sql_stmt_coreContext) {} - -// ExitSql_stmt_core is called when production sql_stmt_core is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSql_stmt_core(ctx *Sql_stmt_coreContext) {} - -// EnterExpr is called when production expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExpr(ctx *ExprContext) {} - -// ExitExpr is called when production expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExpr(ctx *ExprContext) {} - -// EnterOr_subexpr is called when production or_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOr_subexpr(ctx *Or_subexprContext) {} - -// ExitOr_subexpr is called when production or_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOr_subexpr(ctx *Or_subexprContext) {} - -// EnterAnd_subexpr is called when production and_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAnd_subexpr(ctx *And_subexprContext) {} - -// ExitAnd_subexpr is called when production and_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAnd_subexpr(ctx *And_subexprContext) {} - -// EnterXor_subexpr is called when production xor_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterXor_subexpr(ctx *Xor_subexprContext) {} - -// ExitXor_subexpr is called when production xor_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitXor_subexpr(ctx *Xor_subexprContext) {} - -// EnterDistinct_from_op is called when production distinct_from_op is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDistinct_from_op(ctx *Distinct_from_opContext) {} - -// ExitDistinct_from_op is called when production distinct_from_op is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDistinct_from_op(ctx *Distinct_from_opContext) {} - -// EnterCond_expr is called when production cond_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCond_expr(ctx *Cond_exprContext) {} - -// ExitCond_expr is called when production cond_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCond_expr(ctx *Cond_exprContext) {} - -// EnterMatch_op is called when production match_op is entered. -func (s *BaseYQLv1Antlr4Listener) EnterMatch_op(ctx *Match_opContext) {} - -// ExitMatch_op is called when production match_op is exited. -func (s *BaseYQLv1Antlr4Listener) ExitMatch_op(ctx *Match_opContext) {} - -// EnterEq_subexpr is called when production eq_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterEq_subexpr(ctx *Eq_subexprContext) {} - -// ExitEq_subexpr is called when production eq_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitEq_subexpr(ctx *Eq_subexprContext) {} - -// EnterShift_right is called when production shift_right is entered. -func (s *BaseYQLv1Antlr4Listener) EnterShift_right(ctx *Shift_rightContext) {} - -// ExitShift_right is called when production shift_right is exited. -func (s *BaseYQLv1Antlr4Listener) ExitShift_right(ctx *Shift_rightContext) {} - -// EnterRot_right is called when production rot_right is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRot_right(ctx *Rot_rightContext) {} - -// ExitRot_right is called when production rot_right is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRot_right(ctx *Rot_rightContext) {} - -// EnterDouble_question is called when production double_question is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDouble_question(ctx *Double_questionContext) {} - -// ExitDouble_question is called when production double_question is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDouble_question(ctx *Double_questionContext) {} - -// EnterNeq_subexpr is called when production neq_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNeq_subexpr(ctx *Neq_subexprContext) {} - -// ExitNeq_subexpr is called when production neq_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNeq_subexpr(ctx *Neq_subexprContext) {} - -// EnterBit_subexpr is called when production bit_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBit_subexpr(ctx *Bit_subexprContext) {} - -// ExitBit_subexpr is called when production bit_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBit_subexpr(ctx *Bit_subexprContext) {} - -// EnterAdd_subexpr is called when production add_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAdd_subexpr(ctx *Add_subexprContext) {} - -// ExitAdd_subexpr is called when production add_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAdd_subexpr(ctx *Add_subexprContext) {} - -// EnterMul_subexpr is called when production mul_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterMul_subexpr(ctx *Mul_subexprContext) {} - -// ExitMul_subexpr is called when production mul_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitMul_subexpr(ctx *Mul_subexprContext) {} - -// EnterCon_subexpr is called when production con_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCon_subexpr(ctx *Con_subexprContext) {} - -// ExitCon_subexpr is called when production con_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCon_subexpr(ctx *Con_subexprContext) {} - -// EnterUnary_op is called when production unary_op is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUnary_op(ctx *Unary_opContext) {} - -// ExitUnary_op is called when production unary_op is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUnary_op(ctx *Unary_opContext) {} - -// EnterUnary_subexpr_suffix is called when production unary_subexpr_suffix is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUnary_subexpr_suffix(ctx *Unary_subexpr_suffixContext) {} - -// ExitUnary_subexpr_suffix is called when production unary_subexpr_suffix is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUnary_subexpr_suffix(ctx *Unary_subexpr_suffixContext) {} - -// EnterUnary_casual_subexpr is called when production unary_casual_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUnary_casual_subexpr(ctx *Unary_casual_subexprContext) {} - -// ExitUnary_casual_subexpr is called when production unary_casual_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUnary_casual_subexpr(ctx *Unary_casual_subexprContext) {} - -// EnterIn_unary_casual_subexpr is called when production in_unary_casual_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIn_unary_casual_subexpr(ctx *In_unary_casual_subexprContext) {} - -// ExitIn_unary_casual_subexpr is called when production in_unary_casual_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIn_unary_casual_subexpr(ctx *In_unary_casual_subexprContext) {} - -// EnterUnary_subexpr is called when production unary_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUnary_subexpr(ctx *Unary_subexprContext) {} - -// ExitUnary_subexpr is called when production unary_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUnary_subexpr(ctx *Unary_subexprContext) {} - -// EnterIn_unary_subexpr is called when production in_unary_subexpr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIn_unary_subexpr(ctx *In_unary_subexprContext) {} - -// ExitIn_unary_subexpr is called when production in_unary_subexpr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIn_unary_subexpr(ctx *In_unary_subexprContext) {} - -// EnterList_literal is called when production list_literal is entered. -func (s *BaseYQLv1Antlr4Listener) EnterList_literal(ctx *List_literalContext) {} - -// ExitList_literal is called when production list_literal is exited. -func (s *BaseYQLv1Antlr4Listener) ExitList_literal(ctx *List_literalContext) {} - -// EnterExpr_dict_list is called when production expr_dict_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExpr_dict_list(ctx *Expr_dict_listContext) {} - -// ExitExpr_dict_list is called when production expr_dict_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExpr_dict_list(ctx *Expr_dict_listContext) {} - -// EnterDict_literal is called when production dict_literal is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDict_literal(ctx *Dict_literalContext) {} - -// ExitDict_literal is called when production dict_literal is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDict_literal(ctx *Dict_literalContext) {} - -// EnterExpr_struct_list is called when production expr_struct_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExpr_struct_list(ctx *Expr_struct_listContext) {} - -// ExitExpr_struct_list is called when production expr_struct_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExpr_struct_list(ctx *Expr_struct_listContext) {} - -// EnterStruct_literal is called when production struct_literal is entered. -func (s *BaseYQLv1Antlr4Listener) EnterStruct_literal(ctx *Struct_literalContext) {} - -// ExitStruct_literal is called when production struct_literal is exited. -func (s *BaseYQLv1Antlr4Listener) ExitStruct_literal(ctx *Struct_literalContext) {} - -// EnterAtom_expr is called when production atom_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAtom_expr(ctx *Atom_exprContext) {} - -// ExitAtom_expr is called when production atom_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAtom_expr(ctx *Atom_exprContext) {} - -// EnterIn_atom_expr is called when production in_atom_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIn_atom_expr(ctx *In_atom_exprContext) {} - -// ExitIn_atom_expr is called when production in_atom_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIn_atom_expr(ctx *In_atom_exprContext) {} - -// EnterCast_expr is called when production cast_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCast_expr(ctx *Cast_exprContext) {} - -// ExitCast_expr is called when production cast_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCast_expr(ctx *Cast_exprContext) {} - -// EnterBitcast_expr is called when production bitcast_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBitcast_expr(ctx *Bitcast_exprContext) {} - -// ExitBitcast_expr is called when production bitcast_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBitcast_expr(ctx *Bitcast_exprContext) {} - -// EnterExists_expr is called when production exists_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExists_expr(ctx *Exists_exprContext) {} - -// ExitExists_expr is called when production exists_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExists_expr(ctx *Exists_exprContext) {} - -// EnterCase_expr is called when production case_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCase_expr(ctx *Case_exprContext) {} - -// ExitCase_expr is called when production case_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCase_expr(ctx *Case_exprContext) {} - -// EnterLambda is called when production lambda is entered. -func (s *BaseYQLv1Antlr4Listener) EnterLambda(ctx *LambdaContext) {} - -// ExitLambda is called when production lambda is exited. -func (s *BaseYQLv1Antlr4Listener) ExitLambda(ctx *LambdaContext) {} - -// EnterIn_expr is called when production in_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIn_expr(ctx *In_exprContext) {} - -// ExitIn_expr is called when production in_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIn_expr(ctx *In_exprContext) {} - -// EnterJson_api_expr is called when production json_api_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_api_expr(ctx *Json_api_exprContext) {} - -// ExitJson_api_expr is called when production json_api_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_api_expr(ctx *Json_api_exprContext) {} - -// EnterJsonpath_spec is called when production jsonpath_spec is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJsonpath_spec(ctx *Jsonpath_specContext) {} - -// ExitJsonpath_spec is called when production jsonpath_spec is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJsonpath_spec(ctx *Jsonpath_specContext) {} - -// EnterJson_variable_name is called when production json_variable_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_variable_name(ctx *Json_variable_nameContext) {} - -// ExitJson_variable_name is called when production json_variable_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_variable_name(ctx *Json_variable_nameContext) {} - -// EnterJson_variable is called when production json_variable is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_variable(ctx *Json_variableContext) {} - -// ExitJson_variable is called when production json_variable is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_variable(ctx *Json_variableContext) {} - -// EnterJson_variables is called when production json_variables is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_variables(ctx *Json_variablesContext) {} - -// ExitJson_variables is called when production json_variables is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_variables(ctx *Json_variablesContext) {} - -// EnterJson_common_args is called when production json_common_args is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_common_args(ctx *Json_common_argsContext) {} - -// ExitJson_common_args is called when production json_common_args is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_common_args(ctx *Json_common_argsContext) {} - -// EnterJson_case_handler is called when production json_case_handler is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_case_handler(ctx *Json_case_handlerContext) {} - -// ExitJson_case_handler is called when production json_case_handler is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_case_handler(ctx *Json_case_handlerContext) {} - -// EnterJson_value is called when production json_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_value(ctx *Json_valueContext) {} - -// ExitJson_value is called when production json_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_value(ctx *Json_valueContext) {} - -// EnterJson_exists_handler is called when production json_exists_handler is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_exists_handler(ctx *Json_exists_handlerContext) {} - -// ExitJson_exists_handler is called when production json_exists_handler is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_exists_handler(ctx *Json_exists_handlerContext) {} - -// EnterJson_exists is called when production json_exists is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_exists(ctx *Json_existsContext) {} - -// ExitJson_exists is called when production json_exists is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_exists(ctx *Json_existsContext) {} - -// EnterJson_query_wrapper is called when production json_query_wrapper is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_query_wrapper(ctx *Json_query_wrapperContext) {} - -// ExitJson_query_wrapper is called when production json_query_wrapper is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_query_wrapper(ctx *Json_query_wrapperContext) {} - -// EnterJson_query_handler is called when production json_query_handler is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_query_handler(ctx *Json_query_handlerContext) {} - -// ExitJson_query_handler is called when production json_query_handler is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_query_handler(ctx *Json_query_handlerContext) {} - -// EnterJson_query is called when production json_query is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJson_query(ctx *Json_queryContext) {} - -// ExitJson_query is called when production json_query is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJson_query(ctx *Json_queryContext) {} - -// EnterSmart_parenthesis is called when production smart_parenthesis is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSmart_parenthesis(ctx *Smart_parenthesisContext) {} - -// ExitSmart_parenthesis is called when production smart_parenthesis is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSmart_parenthesis(ctx *Smart_parenthesisContext) {} - -// EnterExpr_list is called when production expr_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExpr_list(ctx *Expr_listContext) {} - -// ExitExpr_list is called when production expr_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExpr_list(ctx *Expr_listContext) {} - -// EnterPure_column_list is called when production pure_column_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPure_column_list(ctx *Pure_column_listContext) {} - -// ExitPure_column_list is called when production pure_column_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPure_column_list(ctx *Pure_column_listContext) {} - -// EnterPure_column_or_named is called when production pure_column_or_named is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPure_column_or_named(ctx *Pure_column_or_namedContext) {} - -// ExitPure_column_or_named is called when production pure_column_or_named is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPure_column_or_named(ctx *Pure_column_or_namedContext) {} - -// EnterPure_column_or_named_list is called when production pure_column_or_named_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPure_column_or_named_list(ctx *Pure_column_or_named_listContext) {} - -// ExitPure_column_or_named_list is called when production pure_column_or_named_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPure_column_or_named_list(ctx *Pure_column_or_named_listContext) {} - -// EnterColumn_name is called when production column_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterColumn_name(ctx *Column_nameContext) {} - -// ExitColumn_name is called when production column_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitColumn_name(ctx *Column_nameContext) {} - -// EnterWithout_column_name is called when production without_column_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWithout_column_name(ctx *Without_column_nameContext) {} - -// ExitWithout_column_name is called when production without_column_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWithout_column_name(ctx *Without_column_nameContext) {} - -// EnterColumn_list is called when production column_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterColumn_list(ctx *Column_listContext) {} - -// ExitColumn_list is called when production column_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitColumn_list(ctx *Column_listContext) {} - -// EnterWithout_column_list is called when production without_column_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWithout_column_list(ctx *Without_column_listContext) {} - -// ExitWithout_column_list is called when production without_column_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWithout_column_list(ctx *Without_column_listContext) {} - -// EnterNamed_expr is called when production named_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNamed_expr(ctx *Named_exprContext) {} - -// ExitNamed_expr is called when production named_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNamed_expr(ctx *Named_exprContext) {} - -// EnterNamed_expr_list is called when production named_expr_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNamed_expr_list(ctx *Named_expr_listContext) {} - -// ExitNamed_expr_list is called when production named_expr_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNamed_expr_list(ctx *Named_expr_listContext) {} - -// EnterInvoke_expr is called when production invoke_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInvoke_expr(ctx *Invoke_exprContext) {} - -// ExitInvoke_expr is called when production invoke_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInvoke_expr(ctx *Invoke_exprContext) {} - -// EnterInvoke_expr_tail is called when production invoke_expr_tail is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInvoke_expr_tail(ctx *Invoke_expr_tailContext) {} - -// ExitInvoke_expr_tail is called when production invoke_expr_tail is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInvoke_expr_tail(ctx *Invoke_expr_tailContext) {} - -// EnterUsing_call_expr is called when production using_call_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUsing_call_expr(ctx *Using_call_exprContext) {} - -// ExitUsing_call_expr is called when production using_call_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUsing_call_expr(ctx *Using_call_exprContext) {} - -// EnterKey_expr is called when production key_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKey_expr(ctx *Key_exprContext) {} - -// ExitKey_expr is called when production key_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKey_expr(ctx *Key_exprContext) {} - -// EnterWhen_expr is called when production when_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWhen_expr(ctx *When_exprContext) {} - -// ExitWhen_expr is called when production when_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWhen_expr(ctx *When_exprContext) {} - -// EnterLiteral_value is called when production literal_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterLiteral_value(ctx *Literal_valueContext) {} - -// ExitLiteral_value is called when production literal_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitLiteral_value(ctx *Literal_valueContext) {} - -// EnterBind_parameter is called when production bind_parameter is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBind_parameter(ctx *Bind_parameterContext) {} - -// ExitBind_parameter is called when production bind_parameter is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBind_parameter(ctx *Bind_parameterContext) {} - -// EnterOpt_bind_parameter is called when production opt_bind_parameter is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOpt_bind_parameter(ctx *Opt_bind_parameterContext) {} - -// ExitOpt_bind_parameter is called when production opt_bind_parameter is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOpt_bind_parameter(ctx *Opt_bind_parameterContext) {} - -// EnterBind_parameter_list is called when production bind_parameter_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBind_parameter_list(ctx *Bind_parameter_listContext) {} - -// ExitBind_parameter_list is called when production bind_parameter_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBind_parameter_list(ctx *Bind_parameter_listContext) {} - -// EnterNamed_bind_parameter is called when production named_bind_parameter is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNamed_bind_parameter(ctx *Named_bind_parameterContext) {} - -// ExitNamed_bind_parameter is called when production named_bind_parameter is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNamed_bind_parameter(ctx *Named_bind_parameterContext) {} - -// EnterNamed_bind_parameter_list is called when production named_bind_parameter_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNamed_bind_parameter_list(ctx *Named_bind_parameter_listContext) {} - -// ExitNamed_bind_parameter_list is called when production named_bind_parameter_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNamed_bind_parameter_list(ctx *Named_bind_parameter_listContext) {} - -// EnterSigned_number is called when production signed_number is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSigned_number(ctx *Signed_numberContext) {} - -// ExitSigned_number is called when production signed_number is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSigned_number(ctx *Signed_numberContext) {} - -// EnterType_name_simple is called when production type_name_simple is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_simple(ctx *Type_name_simpleContext) {} - -// ExitType_name_simple is called when production type_name_simple is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_simple(ctx *Type_name_simpleContext) {} - -// EnterInteger_or_bind is called when production integer_or_bind is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInteger_or_bind(ctx *Integer_or_bindContext) {} - -// ExitInteger_or_bind is called when production integer_or_bind is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInteger_or_bind(ctx *Integer_or_bindContext) {} - -// EnterType_name_tag is called when production type_name_tag is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_tag(ctx *Type_name_tagContext) {} - -// ExitType_name_tag is called when production type_name_tag is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_tag(ctx *Type_name_tagContext) {} - -// EnterStruct_arg is called when production struct_arg is entered. -func (s *BaseYQLv1Antlr4Listener) EnterStruct_arg(ctx *Struct_argContext) {} - -// ExitStruct_arg is called when production struct_arg is exited. -func (s *BaseYQLv1Antlr4Listener) ExitStruct_arg(ctx *Struct_argContext) {} - -// EnterStruct_arg_positional is called when production struct_arg_positional is entered. -func (s *BaseYQLv1Antlr4Listener) EnterStruct_arg_positional(ctx *Struct_arg_positionalContext) {} - -// ExitStruct_arg_positional is called when production struct_arg_positional is exited. -func (s *BaseYQLv1Antlr4Listener) ExitStruct_arg_positional(ctx *Struct_arg_positionalContext) {} - -// EnterVariant_arg is called when production variant_arg is entered. -func (s *BaseYQLv1Antlr4Listener) EnterVariant_arg(ctx *Variant_argContext) {} - -// ExitVariant_arg is called when production variant_arg is exited. -func (s *BaseYQLv1Antlr4Listener) ExitVariant_arg(ctx *Variant_argContext) {} - -// EnterCallable_arg is called when production callable_arg is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCallable_arg(ctx *Callable_argContext) {} - -// ExitCallable_arg is called when production callable_arg is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCallable_arg(ctx *Callable_argContext) {} - -// EnterCallable_arg_list is called when production callable_arg_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCallable_arg_list(ctx *Callable_arg_listContext) {} - -// ExitCallable_arg_list is called when production callable_arg_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCallable_arg_list(ctx *Callable_arg_listContext) {} - -// EnterType_name_decimal is called when production type_name_decimal is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_decimal(ctx *Type_name_decimalContext) {} - -// ExitType_name_decimal is called when production type_name_decimal is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_decimal(ctx *Type_name_decimalContext) {} - -// EnterType_name_optional is called when production type_name_optional is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_optional(ctx *Type_name_optionalContext) {} - -// ExitType_name_optional is called when production type_name_optional is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_optional(ctx *Type_name_optionalContext) {} - -// EnterType_name_tuple is called when production type_name_tuple is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_tuple(ctx *Type_name_tupleContext) {} - -// ExitType_name_tuple is called when production type_name_tuple is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_tuple(ctx *Type_name_tupleContext) {} - -// EnterType_name_struct is called when production type_name_struct is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_struct(ctx *Type_name_structContext) {} - -// ExitType_name_struct is called when production type_name_struct is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_struct(ctx *Type_name_structContext) {} - -// EnterType_name_variant is called when production type_name_variant is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_variant(ctx *Type_name_variantContext) {} - -// ExitType_name_variant is called when production type_name_variant is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_variant(ctx *Type_name_variantContext) {} - -// EnterType_name_list is called when production type_name_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_list(ctx *Type_name_listContext) {} - -// ExitType_name_list is called when production type_name_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_list(ctx *Type_name_listContext) {} - -// EnterType_name_stream is called when production type_name_stream is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_stream(ctx *Type_name_streamContext) {} - -// ExitType_name_stream is called when production type_name_stream is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_stream(ctx *Type_name_streamContext) {} - -// EnterType_name_flow is called when production type_name_flow is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_flow(ctx *Type_name_flowContext) {} - -// ExitType_name_flow is called when production type_name_flow is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_flow(ctx *Type_name_flowContext) {} - -// EnterType_name_dict is called when production type_name_dict is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_dict(ctx *Type_name_dictContext) {} - -// ExitType_name_dict is called when production type_name_dict is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_dict(ctx *Type_name_dictContext) {} - -// EnterType_name_set is called when production type_name_set is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_set(ctx *Type_name_setContext) {} - -// ExitType_name_set is called when production type_name_set is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_set(ctx *Type_name_setContext) {} - -// EnterType_name_enum is called when production type_name_enum is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_enum(ctx *Type_name_enumContext) {} - -// ExitType_name_enum is called when production type_name_enum is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_enum(ctx *Type_name_enumContext) {} - -// EnterType_name_resource is called when production type_name_resource is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_resource(ctx *Type_name_resourceContext) {} - -// ExitType_name_resource is called when production type_name_resource is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_resource(ctx *Type_name_resourceContext) {} - -// EnterType_name_tagged is called when production type_name_tagged is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_tagged(ctx *Type_name_taggedContext) {} - -// ExitType_name_tagged is called when production type_name_tagged is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_tagged(ctx *Type_name_taggedContext) {} - -// EnterType_name_callable is called when production type_name_callable is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_callable(ctx *Type_name_callableContext) {} - -// ExitType_name_callable is called when production type_name_callable is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_callable(ctx *Type_name_callableContext) {} - -// EnterType_name_composite is called when production type_name_composite is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_composite(ctx *Type_name_compositeContext) {} - -// ExitType_name_composite is called when production type_name_composite is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_composite(ctx *Type_name_compositeContext) {} - -// EnterType_name is called when production type_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name(ctx *Type_nameContext) {} - -// ExitType_name is called when production type_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name(ctx *Type_nameContext) {} - -// EnterType_name_or_bind is called when production type_name_or_bind is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_name_or_bind(ctx *Type_name_or_bindContext) {} - -// ExitType_name_or_bind is called when production type_name_or_bind is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_name_or_bind(ctx *Type_name_or_bindContext) {} - -// EnterValue_constructor_literal is called when production value_constructor_literal is entered. -func (s *BaseYQLv1Antlr4Listener) EnterValue_constructor_literal(ctx *Value_constructor_literalContext) {} - -// ExitValue_constructor_literal is called when production value_constructor_literal is exited. -func (s *BaseYQLv1Antlr4Listener) ExitValue_constructor_literal(ctx *Value_constructor_literalContext) {} - -// EnterValue_constructor is called when production value_constructor is entered. -func (s *BaseYQLv1Antlr4Listener) EnterValue_constructor(ctx *Value_constructorContext) {} - -// ExitValue_constructor is called when production value_constructor is exited. -func (s *BaseYQLv1Antlr4Listener) ExitValue_constructor(ctx *Value_constructorContext) {} - -// EnterDeclare_stmt is called when production declare_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDeclare_stmt(ctx *Declare_stmtContext) {} - -// ExitDeclare_stmt is called when production declare_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDeclare_stmt(ctx *Declare_stmtContext) {} - -// EnterModule_path is called when production module_path is entered. -func (s *BaseYQLv1Antlr4Listener) EnterModule_path(ctx *Module_pathContext) {} - -// ExitModule_path is called when production module_path is exited. -func (s *BaseYQLv1Antlr4Listener) ExitModule_path(ctx *Module_pathContext) {} - -// EnterImport_stmt is called when production import_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterImport_stmt(ctx *Import_stmtContext) {} - -// ExitImport_stmt is called when production import_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitImport_stmt(ctx *Import_stmtContext) {} - -// EnterExport_stmt is called when production export_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExport_stmt(ctx *Export_stmtContext) {} - -// ExitExport_stmt is called when production export_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExport_stmt(ctx *Export_stmtContext) {} - -// EnterCall_action is called when production call_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCall_action(ctx *Call_actionContext) {} - -// ExitCall_action is called when production call_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCall_action(ctx *Call_actionContext) {} - -// EnterInline_action is called when production inline_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInline_action(ctx *Inline_actionContext) {} - -// ExitInline_action is called when production inline_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInline_action(ctx *Inline_actionContext) {} - -// EnterDo_stmt is called when production do_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDo_stmt(ctx *Do_stmtContext) {} - -// ExitDo_stmt is called when production do_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDo_stmt(ctx *Do_stmtContext) {} - -// EnterPragma_stmt is called when production pragma_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPragma_stmt(ctx *Pragma_stmtContext) {} - -// ExitPragma_stmt is called when production pragma_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPragma_stmt(ctx *Pragma_stmtContext) {} - -// EnterPragma_value is called when production pragma_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPragma_value(ctx *Pragma_valueContext) {} - -// ExitPragma_value is called when production pragma_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPragma_value(ctx *Pragma_valueContext) {} - -// EnterSort_specification is called when production sort_specification is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSort_specification(ctx *Sort_specificationContext) {} - -// ExitSort_specification is called when production sort_specification is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSort_specification(ctx *Sort_specificationContext) {} - -// EnterSort_specification_list is called when production sort_specification_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSort_specification_list(ctx *Sort_specification_listContext) {} - -// ExitSort_specification_list is called when production sort_specification_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSort_specification_list(ctx *Sort_specification_listContext) {} - -// EnterSelect_stmt is called when production select_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSelect_stmt(ctx *Select_stmtContext) {} - -// ExitSelect_stmt is called when production select_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSelect_stmt(ctx *Select_stmtContext) {} - -// EnterSelect_unparenthesized_stmt is called when production select_unparenthesized_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSelect_unparenthesized_stmt(ctx *Select_unparenthesized_stmtContext) {} - -// ExitSelect_unparenthesized_stmt is called when production select_unparenthesized_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSelect_unparenthesized_stmt(ctx *Select_unparenthesized_stmtContext) {} - -// EnterSelect_kind_parenthesis is called when production select_kind_parenthesis is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSelect_kind_parenthesis(ctx *Select_kind_parenthesisContext) {} - -// ExitSelect_kind_parenthesis is called when production select_kind_parenthesis is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSelect_kind_parenthesis(ctx *Select_kind_parenthesisContext) {} - -// EnterSelect_op is called when production select_op is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSelect_op(ctx *Select_opContext) {} - -// ExitSelect_op is called when production select_op is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSelect_op(ctx *Select_opContext) {} - -// EnterSelect_kind_partial is called when production select_kind_partial is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSelect_kind_partial(ctx *Select_kind_partialContext) {} - -// ExitSelect_kind_partial is called when production select_kind_partial is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSelect_kind_partial(ctx *Select_kind_partialContext) {} - -// EnterSelect_kind is called when production select_kind is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSelect_kind(ctx *Select_kindContext) {} - -// ExitSelect_kind is called when production select_kind is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSelect_kind(ctx *Select_kindContext) {} - -// EnterProcess_core is called when production process_core is entered. -func (s *BaseYQLv1Antlr4Listener) EnterProcess_core(ctx *Process_coreContext) {} - -// ExitProcess_core is called when production process_core is exited. -func (s *BaseYQLv1Antlr4Listener) ExitProcess_core(ctx *Process_coreContext) {} - -// EnterExternal_call_param is called when production external_call_param is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExternal_call_param(ctx *External_call_paramContext) {} - -// ExitExternal_call_param is called when production external_call_param is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExternal_call_param(ctx *External_call_paramContext) {} - -// EnterExternal_call_settings is called when production external_call_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExternal_call_settings(ctx *External_call_settingsContext) {} - -// ExitExternal_call_settings is called when production external_call_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExternal_call_settings(ctx *External_call_settingsContext) {} - -// EnterReduce_core is called when production reduce_core is entered. -func (s *BaseYQLv1Antlr4Listener) EnterReduce_core(ctx *Reduce_coreContext) {} - -// ExitReduce_core is called when production reduce_core is exited. -func (s *BaseYQLv1Antlr4Listener) ExitReduce_core(ctx *Reduce_coreContext) {} - -// EnterOpt_set_quantifier is called when production opt_set_quantifier is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOpt_set_quantifier(ctx *Opt_set_quantifierContext) {} - -// ExitOpt_set_quantifier is called when production opt_set_quantifier is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOpt_set_quantifier(ctx *Opt_set_quantifierContext) {} - -// EnterSelect_core is called when production select_core is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSelect_core(ctx *Select_coreContext) {} - -// ExitSelect_core is called when production select_core is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSelect_core(ctx *Select_coreContext) {} - -// EnterRow_pattern_recognition_clause is called when production row_pattern_recognition_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_recognition_clause(ctx *Row_pattern_recognition_clauseContext) {} - -// ExitRow_pattern_recognition_clause is called when production row_pattern_recognition_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_recognition_clause(ctx *Row_pattern_recognition_clauseContext) {} - -// EnterRow_pattern_rows_per_match is called when production row_pattern_rows_per_match is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_rows_per_match(ctx *Row_pattern_rows_per_matchContext) {} - -// ExitRow_pattern_rows_per_match is called when production row_pattern_rows_per_match is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_rows_per_match(ctx *Row_pattern_rows_per_matchContext) {} - -// EnterRow_pattern_empty_match_handling is called when production row_pattern_empty_match_handling is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_empty_match_handling(ctx *Row_pattern_empty_match_handlingContext) {} - -// ExitRow_pattern_empty_match_handling is called when production row_pattern_empty_match_handling is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_empty_match_handling(ctx *Row_pattern_empty_match_handlingContext) {} - -// EnterRow_pattern_measures is called when production row_pattern_measures is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_measures(ctx *Row_pattern_measuresContext) {} - -// ExitRow_pattern_measures is called when production row_pattern_measures is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_measures(ctx *Row_pattern_measuresContext) {} - -// EnterRow_pattern_measure_list is called when production row_pattern_measure_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_measure_list(ctx *Row_pattern_measure_listContext) {} - -// ExitRow_pattern_measure_list is called when production row_pattern_measure_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_measure_list(ctx *Row_pattern_measure_listContext) {} - -// EnterRow_pattern_measure_definition is called when production row_pattern_measure_definition is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_measure_definition(ctx *Row_pattern_measure_definitionContext) {} - -// ExitRow_pattern_measure_definition is called when production row_pattern_measure_definition is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_measure_definition(ctx *Row_pattern_measure_definitionContext) {} - -// EnterRow_pattern_common_syntax is called when production row_pattern_common_syntax is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_common_syntax(ctx *Row_pattern_common_syntaxContext) {} - -// ExitRow_pattern_common_syntax is called when production row_pattern_common_syntax is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_common_syntax(ctx *Row_pattern_common_syntaxContext) {} - -// EnterRow_pattern_skip_to is called when production row_pattern_skip_to is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_skip_to(ctx *Row_pattern_skip_toContext) {} - -// ExitRow_pattern_skip_to is called when production row_pattern_skip_to is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_skip_to(ctx *Row_pattern_skip_toContext) {} - -// EnterRow_pattern_skip_to_variable_name is called when production row_pattern_skip_to_variable_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_skip_to_variable_name(ctx *Row_pattern_skip_to_variable_nameContext) {} - -// ExitRow_pattern_skip_to_variable_name is called when production row_pattern_skip_to_variable_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_skip_to_variable_name(ctx *Row_pattern_skip_to_variable_nameContext) {} - -// EnterRow_pattern_initial_or_seek is called when production row_pattern_initial_or_seek is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_initial_or_seek(ctx *Row_pattern_initial_or_seekContext) {} - -// ExitRow_pattern_initial_or_seek is called when production row_pattern_initial_or_seek is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_initial_or_seek(ctx *Row_pattern_initial_or_seekContext) {} - -// EnterRow_pattern is called when production row_pattern is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern(ctx *Row_patternContext) {} - -// ExitRow_pattern is called when production row_pattern is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern(ctx *Row_patternContext) {} - -// EnterRow_pattern_term is called when production row_pattern_term is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_term(ctx *Row_pattern_termContext) {} - -// ExitRow_pattern_term is called when production row_pattern_term is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_term(ctx *Row_pattern_termContext) {} - -// EnterRow_pattern_factor is called when production row_pattern_factor is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_factor(ctx *Row_pattern_factorContext) {} - -// ExitRow_pattern_factor is called when production row_pattern_factor is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_factor(ctx *Row_pattern_factorContext) {} - -// EnterRow_pattern_quantifier is called when production row_pattern_quantifier is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_quantifier(ctx *Row_pattern_quantifierContext) {} - -// ExitRow_pattern_quantifier is called when production row_pattern_quantifier is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_quantifier(ctx *Row_pattern_quantifierContext) {} - -// EnterRow_pattern_primary is called when production row_pattern_primary is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_primary(ctx *Row_pattern_primaryContext) {} - -// ExitRow_pattern_primary is called when production row_pattern_primary is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_primary(ctx *Row_pattern_primaryContext) {} - -// EnterRow_pattern_primary_variable_name is called when production row_pattern_primary_variable_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_primary_variable_name(ctx *Row_pattern_primary_variable_nameContext) {} - -// ExitRow_pattern_primary_variable_name is called when production row_pattern_primary_variable_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_primary_variable_name(ctx *Row_pattern_primary_variable_nameContext) {} - -// EnterRow_pattern_permute is called when production row_pattern_permute is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_permute(ctx *Row_pattern_permuteContext) {} - -// ExitRow_pattern_permute is called when production row_pattern_permute is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_permute(ctx *Row_pattern_permuteContext) {} - -// EnterRow_pattern_subset_clause is called when production row_pattern_subset_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_subset_clause(ctx *Row_pattern_subset_clauseContext) {} - -// ExitRow_pattern_subset_clause is called when production row_pattern_subset_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_subset_clause(ctx *Row_pattern_subset_clauseContext) {} - -// EnterRow_pattern_subset_list is called when production row_pattern_subset_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_subset_list(ctx *Row_pattern_subset_listContext) {} - -// ExitRow_pattern_subset_list is called when production row_pattern_subset_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_subset_list(ctx *Row_pattern_subset_listContext) {} - -// EnterRow_pattern_subset_item is called when production row_pattern_subset_item is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_subset_item(ctx *Row_pattern_subset_itemContext) {} - -// ExitRow_pattern_subset_item is called when production row_pattern_subset_item is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_subset_item(ctx *Row_pattern_subset_itemContext) {} - -// EnterRow_pattern_subset_item_variable_name is called when production row_pattern_subset_item_variable_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_subset_item_variable_name(ctx *Row_pattern_subset_item_variable_nameContext) {} - -// ExitRow_pattern_subset_item_variable_name is called when production row_pattern_subset_item_variable_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_subset_item_variable_name(ctx *Row_pattern_subset_item_variable_nameContext) {} - -// EnterRow_pattern_subset_rhs is called when production row_pattern_subset_rhs is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_subset_rhs(ctx *Row_pattern_subset_rhsContext) {} - -// ExitRow_pattern_subset_rhs is called when production row_pattern_subset_rhs is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_subset_rhs(ctx *Row_pattern_subset_rhsContext) {} - -// EnterRow_pattern_subset_rhs_variable_name is called when production row_pattern_subset_rhs_variable_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_subset_rhs_variable_name(ctx *Row_pattern_subset_rhs_variable_nameContext) {} - -// ExitRow_pattern_subset_rhs_variable_name is called when production row_pattern_subset_rhs_variable_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_subset_rhs_variable_name(ctx *Row_pattern_subset_rhs_variable_nameContext) {} - -// EnterRow_pattern_definition_list is called when production row_pattern_definition_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_definition_list(ctx *Row_pattern_definition_listContext) {} - -// ExitRow_pattern_definition_list is called when production row_pattern_definition_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_definition_list(ctx *Row_pattern_definition_listContext) {} - -// EnterRow_pattern_definition is called when production row_pattern_definition is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_definition(ctx *Row_pattern_definitionContext) {} - -// ExitRow_pattern_definition is called when production row_pattern_definition is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_definition(ctx *Row_pattern_definitionContext) {} - -// EnterRow_pattern_definition_variable_name is called when production row_pattern_definition_variable_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_definition_variable_name(ctx *Row_pattern_definition_variable_nameContext) {} - -// ExitRow_pattern_definition_variable_name is called when production row_pattern_definition_variable_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_definition_variable_name(ctx *Row_pattern_definition_variable_nameContext) {} - -// EnterRow_pattern_definition_search_condition is called when production row_pattern_definition_search_condition is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_definition_search_condition(ctx *Row_pattern_definition_search_conditionContext) {} - -// ExitRow_pattern_definition_search_condition is called when production row_pattern_definition_search_condition is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_definition_search_condition(ctx *Row_pattern_definition_search_conditionContext) {} - -// EnterSearch_condition is called when production search_condition is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSearch_condition(ctx *Search_conditionContext) {} - -// ExitSearch_condition is called when production search_condition is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSearch_condition(ctx *Search_conditionContext) {} - -// EnterRow_pattern_variable_name is called when production row_pattern_variable_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRow_pattern_variable_name(ctx *Row_pattern_variable_nameContext) {} - -// ExitRow_pattern_variable_name is called when production row_pattern_variable_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRow_pattern_variable_name(ctx *Row_pattern_variable_nameContext) {} - -// EnterOrder_by_clause is called when production order_by_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOrder_by_clause(ctx *Order_by_clauseContext) {} - -// ExitOrder_by_clause is called when production order_by_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOrder_by_clause(ctx *Order_by_clauseContext) {} - -// EnterExt_order_by_clause is called when production ext_order_by_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExt_order_by_clause(ctx *Ext_order_by_clauseContext) {} - -// ExitExt_order_by_clause is called when production ext_order_by_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExt_order_by_clause(ctx *Ext_order_by_clauseContext) {} - -// EnterGroup_by_clause is called when production group_by_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterGroup_by_clause(ctx *Group_by_clauseContext) {} - -// ExitGroup_by_clause is called when production group_by_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitGroup_by_clause(ctx *Group_by_clauseContext) {} - -// EnterGrouping_element_list is called when production grouping_element_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterGrouping_element_list(ctx *Grouping_element_listContext) {} - -// ExitGrouping_element_list is called when production grouping_element_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitGrouping_element_list(ctx *Grouping_element_listContext) {} - -// EnterGrouping_element is called when production grouping_element is entered. -func (s *BaseYQLv1Antlr4Listener) EnterGrouping_element(ctx *Grouping_elementContext) {} - -// ExitGrouping_element is called when production grouping_element is exited. -func (s *BaseYQLv1Antlr4Listener) ExitGrouping_element(ctx *Grouping_elementContext) {} - -// EnterOrdinary_grouping_set is called when production ordinary_grouping_set is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOrdinary_grouping_set(ctx *Ordinary_grouping_setContext) {} - -// ExitOrdinary_grouping_set is called when production ordinary_grouping_set is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOrdinary_grouping_set(ctx *Ordinary_grouping_setContext) {} - -// EnterOrdinary_grouping_set_list is called when production ordinary_grouping_set_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOrdinary_grouping_set_list(ctx *Ordinary_grouping_set_listContext) {} - -// ExitOrdinary_grouping_set_list is called when production ordinary_grouping_set_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOrdinary_grouping_set_list(ctx *Ordinary_grouping_set_listContext) {} - -// EnterRollup_list is called when production rollup_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRollup_list(ctx *Rollup_listContext) {} - -// ExitRollup_list is called when production rollup_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRollup_list(ctx *Rollup_listContext) {} - -// EnterCube_list is called when production cube_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCube_list(ctx *Cube_listContext) {} - -// ExitCube_list is called when production cube_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCube_list(ctx *Cube_listContext) {} - -// EnterGrouping_sets_specification is called when production grouping_sets_specification is entered. -func (s *BaseYQLv1Antlr4Listener) EnterGrouping_sets_specification(ctx *Grouping_sets_specificationContext) {} - -// ExitGrouping_sets_specification is called when production grouping_sets_specification is exited. -func (s *BaseYQLv1Antlr4Listener) ExitGrouping_sets_specification(ctx *Grouping_sets_specificationContext) {} - -// EnterHopping_window_specification is called when production hopping_window_specification is entered. -func (s *BaseYQLv1Antlr4Listener) EnterHopping_window_specification(ctx *Hopping_window_specificationContext) {} - -// ExitHopping_window_specification is called when production hopping_window_specification is exited. -func (s *BaseYQLv1Antlr4Listener) ExitHopping_window_specification(ctx *Hopping_window_specificationContext) {} - -// EnterResult_column is called when production result_column is entered. -func (s *BaseYQLv1Antlr4Listener) EnterResult_column(ctx *Result_columnContext) {} - -// ExitResult_column is called when production result_column is exited. -func (s *BaseYQLv1Antlr4Listener) ExitResult_column(ctx *Result_columnContext) {} - -// EnterJoin_source is called when production join_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJoin_source(ctx *Join_sourceContext) {} - -// ExitJoin_source is called when production join_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJoin_source(ctx *Join_sourceContext) {} - -// EnterNamed_column is called when production named_column is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNamed_column(ctx *Named_columnContext) {} - -// ExitNamed_column is called when production named_column is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNamed_column(ctx *Named_columnContext) {} - -// EnterFlatten_by_arg is called when production flatten_by_arg is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFlatten_by_arg(ctx *Flatten_by_argContext) {} - -// ExitFlatten_by_arg is called when production flatten_by_arg is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFlatten_by_arg(ctx *Flatten_by_argContext) {} - -// EnterFlatten_source is called when production flatten_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFlatten_source(ctx *Flatten_sourceContext) {} - -// ExitFlatten_source is called when production flatten_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFlatten_source(ctx *Flatten_sourceContext) {} - -// EnterNamed_single_source is called when production named_single_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNamed_single_source(ctx *Named_single_sourceContext) {} - -// ExitNamed_single_source is called when production named_single_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNamed_single_source(ctx *Named_single_sourceContext) {} - -// EnterSingle_source is called when production single_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSingle_source(ctx *Single_sourceContext) {} - -// ExitSingle_source is called when production single_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSingle_source(ctx *Single_sourceContext) {} - -// EnterSample_clause is called when production sample_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSample_clause(ctx *Sample_clauseContext) {} - -// ExitSample_clause is called when production sample_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSample_clause(ctx *Sample_clauseContext) {} - -// EnterTablesample_clause is called when production tablesample_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTablesample_clause(ctx *Tablesample_clauseContext) {} - -// ExitTablesample_clause is called when production tablesample_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTablesample_clause(ctx *Tablesample_clauseContext) {} - -// EnterSampling_mode is called when production sampling_mode is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSampling_mode(ctx *Sampling_modeContext) {} - -// ExitSampling_mode is called when production sampling_mode is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSampling_mode(ctx *Sampling_modeContext) {} - -// EnterRepeatable_clause is called when production repeatable_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRepeatable_clause(ctx *Repeatable_clauseContext) {} - -// ExitRepeatable_clause is called when production repeatable_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRepeatable_clause(ctx *Repeatable_clauseContext) {} - -// EnterJoin_op is called when production join_op is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJoin_op(ctx *Join_opContext) {} - -// ExitJoin_op is called when production join_op is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJoin_op(ctx *Join_opContext) {} - -// EnterJoin_constraint is called when production join_constraint is entered. -func (s *BaseYQLv1Antlr4Listener) EnterJoin_constraint(ctx *Join_constraintContext) {} - -// ExitJoin_constraint is called when production join_constraint is exited. -func (s *BaseYQLv1Antlr4Listener) ExitJoin_constraint(ctx *Join_constraintContext) {} - -// EnterReturning_columns_list is called when production returning_columns_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterReturning_columns_list(ctx *Returning_columns_listContext) {} - -// ExitReturning_columns_list is called when production returning_columns_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitReturning_columns_list(ctx *Returning_columns_listContext) {} - -// EnterInto_table_stmt is called when production into_table_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInto_table_stmt(ctx *Into_table_stmtContext) {} - -// ExitInto_table_stmt is called when production into_table_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInto_table_stmt(ctx *Into_table_stmtContext) {} - -// EnterInto_values_source is called when production into_values_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInto_values_source(ctx *Into_values_sourceContext) {} - -// ExitInto_values_source is called when production into_values_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInto_values_source(ctx *Into_values_sourceContext) {} - -// EnterValues_stmt is called when production values_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterValues_stmt(ctx *Values_stmtContext) {} - -// ExitValues_stmt is called when production values_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitValues_stmt(ctx *Values_stmtContext) {} - -// EnterValues_source is called when production values_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterValues_source(ctx *Values_sourceContext) {} - -// ExitValues_source is called when production values_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitValues_source(ctx *Values_sourceContext) {} - -// EnterValues_source_row_list is called when production values_source_row_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterValues_source_row_list(ctx *Values_source_row_listContext) {} - -// ExitValues_source_row_list is called when production values_source_row_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitValues_source_row_list(ctx *Values_source_row_listContext) {} - -// EnterValues_source_row is called when production values_source_row is entered. -func (s *BaseYQLv1Antlr4Listener) EnterValues_source_row(ctx *Values_source_rowContext) {} - -// ExitValues_source_row is called when production values_source_row is exited. -func (s *BaseYQLv1Antlr4Listener) ExitValues_source_row(ctx *Values_source_rowContext) {} - -// EnterSimple_values_source is called when production simple_values_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSimple_values_source(ctx *Simple_values_sourceContext) {} - -// ExitSimple_values_source is called when production simple_values_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSimple_values_source(ctx *Simple_values_sourceContext) {} - -// EnterCreate_external_data_source_stmt is called when production create_external_data_source_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_external_data_source_stmt(ctx *Create_external_data_source_stmtContext) {} - -// ExitCreate_external_data_source_stmt is called when production create_external_data_source_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_external_data_source_stmt(ctx *Create_external_data_source_stmtContext) {} - -// EnterAlter_external_data_source_stmt is called when production alter_external_data_source_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_external_data_source_stmt(ctx *Alter_external_data_source_stmtContext) {} - -// ExitAlter_external_data_source_stmt is called when production alter_external_data_source_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_external_data_source_stmt(ctx *Alter_external_data_source_stmtContext) {} - -// EnterAlter_external_data_source_action is called when production alter_external_data_source_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_external_data_source_action(ctx *Alter_external_data_source_actionContext) {} - -// ExitAlter_external_data_source_action is called when production alter_external_data_source_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_external_data_source_action(ctx *Alter_external_data_source_actionContext) {} - -// EnterDrop_external_data_source_stmt is called when production drop_external_data_source_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_external_data_source_stmt(ctx *Drop_external_data_source_stmtContext) {} - -// ExitDrop_external_data_source_stmt is called when production drop_external_data_source_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_external_data_source_stmt(ctx *Drop_external_data_source_stmtContext) {} - -// EnterCreate_view_stmt is called when production create_view_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_view_stmt(ctx *Create_view_stmtContext) {} - -// ExitCreate_view_stmt is called when production create_view_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_view_stmt(ctx *Create_view_stmtContext) {} - -// EnterDrop_view_stmt is called when production drop_view_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_view_stmt(ctx *Drop_view_stmtContext) {} - -// ExitDrop_view_stmt is called when production drop_view_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_view_stmt(ctx *Drop_view_stmtContext) {} - -// EnterUpsert_object_stmt is called when production upsert_object_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUpsert_object_stmt(ctx *Upsert_object_stmtContext) {} - -// ExitUpsert_object_stmt is called when production upsert_object_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUpsert_object_stmt(ctx *Upsert_object_stmtContext) {} - -// EnterCreate_object_stmt is called when production create_object_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_object_stmt(ctx *Create_object_stmtContext) {} - -// ExitCreate_object_stmt is called when production create_object_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_object_stmt(ctx *Create_object_stmtContext) {} - -// EnterCreate_object_features is called when production create_object_features is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_object_features(ctx *Create_object_featuresContext) {} - -// ExitCreate_object_features is called when production create_object_features is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_object_features(ctx *Create_object_featuresContext) {} - -// EnterAlter_object_stmt is called when production alter_object_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_object_stmt(ctx *Alter_object_stmtContext) {} - -// ExitAlter_object_stmt is called when production alter_object_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_object_stmt(ctx *Alter_object_stmtContext) {} - -// EnterAlter_object_features is called when production alter_object_features is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_object_features(ctx *Alter_object_featuresContext) {} - -// ExitAlter_object_features is called when production alter_object_features is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_object_features(ctx *Alter_object_featuresContext) {} - -// EnterDrop_object_stmt is called when production drop_object_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_object_stmt(ctx *Drop_object_stmtContext) {} - -// ExitDrop_object_stmt is called when production drop_object_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_object_stmt(ctx *Drop_object_stmtContext) {} - -// EnterDrop_object_features is called when production drop_object_features is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_object_features(ctx *Drop_object_featuresContext) {} - -// ExitDrop_object_features is called when production drop_object_features is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_object_features(ctx *Drop_object_featuresContext) {} - -// EnterObject_feature_value is called when production object_feature_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterObject_feature_value(ctx *Object_feature_valueContext) {} - -// ExitObject_feature_value is called when production object_feature_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitObject_feature_value(ctx *Object_feature_valueContext) {} - -// EnterObject_feature_kv is called when production object_feature_kv is entered. -func (s *BaseYQLv1Antlr4Listener) EnterObject_feature_kv(ctx *Object_feature_kvContext) {} - -// ExitObject_feature_kv is called when production object_feature_kv is exited. -func (s *BaseYQLv1Antlr4Listener) ExitObject_feature_kv(ctx *Object_feature_kvContext) {} - -// EnterObject_feature_flag is called when production object_feature_flag is entered. -func (s *BaseYQLv1Antlr4Listener) EnterObject_feature_flag(ctx *Object_feature_flagContext) {} - -// ExitObject_feature_flag is called when production object_feature_flag is exited. -func (s *BaseYQLv1Antlr4Listener) ExitObject_feature_flag(ctx *Object_feature_flagContext) {} - -// EnterObject_feature is called when production object_feature is entered. -func (s *BaseYQLv1Antlr4Listener) EnterObject_feature(ctx *Object_featureContext) {} - -// ExitObject_feature is called when production object_feature is exited. -func (s *BaseYQLv1Antlr4Listener) ExitObject_feature(ctx *Object_featureContext) {} - -// EnterObject_features is called when production object_features is entered. -func (s *BaseYQLv1Antlr4Listener) EnterObject_features(ctx *Object_featuresContext) {} - -// ExitObject_features is called when production object_features is exited. -func (s *BaseYQLv1Antlr4Listener) ExitObject_features(ctx *Object_featuresContext) {} - -// EnterObject_type_ref is called when production object_type_ref is entered. -func (s *BaseYQLv1Antlr4Listener) EnterObject_type_ref(ctx *Object_type_refContext) {} - -// ExitObject_type_ref is called when production object_type_ref is exited. -func (s *BaseYQLv1Antlr4Listener) ExitObject_type_ref(ctx *Object_type_refContext) {} - -// EnterCreate_table_stmt is called when production create_table_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_table_stmt(ctx *Create_table_stmtContext) {} - -// ExitCreate_table_stmt is called when production create_table_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_table_stmt(ctx *Create_table_stmtContext) {} - -// EnterCreate_table_entry is called when production create_table_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_table_entry(ctx *Create_table_entryContext) {} - -// ExitCreate_table_entry is called when production create_table_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_table_entry(ctx *Create_table_entryContext) {} - -// EnterCreate_backup_collection_stmt is called when production create_backup_collection_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_backup_collection_stmt(ctx *Create_backup_collection_stmtContext) {} - -// ExitCreate_backup_collection_stmt is called when production create_backup_collection_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_backup_collection_stmt(ctx *Create_backup_collection_stmtContext) {} - -// EnterAlter_backup_collection_stmt is called when production alter_backup_collection_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_backup_collection_stmt(ctx *Alter_backup_collection_stmtContext) {} - -// ExitAlter_backup_collection_stmt is called when production alter_backup_collection_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_backup_collection_stmt(ctx *Alter_backup_collection_stmtContext) {} - -// EnterDrop_backup_collection_stmt is called when production drop_backup_collection_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_backup_collection_stmt(ctx *Drop_backup_collection_stmtContext) {} - -// ExitDrop_backup_collection_stmt is called when production drop_backup_collection_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_backup_collection_stmt(ctx *Drop_backup_collection_stmtContext) {} - -// EnterCreate_backup_collection_entries is called when production create_backup_collection_entries is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_backup_collection_entries(ctx *Create_backup_collection_entriesContext) {} - -// ExitCreate_backup_collection_entries is called when production create_backup_collection_entries is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_backup_collection_entries(ctx *Create_backup_collection_entriesContext) {} - -// EnterCreate_backup_collection_entries_many is called when production create_backup_collection_entries_many is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_backup_collection_entries_many(ctx *Create_backup_collection_entries_manyContext) {} - -// ExitCreate_backup_collection_entries_many is called when production create_backup_collection_entries_many is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_backup_collection_entries_many(ctx *Create_backup_collection_entries_manyContext) {} - -// EnterTable_list is called when production table_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_list(ctx *Table_listContext) {} - -// ExitTable_list is called when production table_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_list(ctx *Table_listContext) {} - -// EnterAlter_backup_collection_actions is called when production alter_backup_collection_actions is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_backup_collection_actions(ctx *Alter_backup_collection_actionsContext) {} - -// ExitAlter_backup_collection_actions is called when production alter_backup_collection_actions is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_backup_collection_actions(ctx *Alter_backup_collection_actionsContext) {} - -// EnterAlter_backup_collection_action is called when production alter_backup_collection_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_backup_collection_action(ctx *Alter_backup_collection_actionContext) {} - -// ExitAlter_backup_collection_action is called when production alter_backup_collection_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_backup_collection_action(ctx *Alter_backup_collection_actionContext) {} - -// EnterAlter_backup_collection_entries is called when production alter_backup_collection_entries is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_backup_collection_entries(ctx *Alter_backup_collection_entriesContext) {} - -// ExitAlter_backup_collection_entries is called when production alter_backup_collection_entries is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_backup_collection_entries(ctx *Alter_backup_collection_entriesContext) {} - -// EnterAlter_backup_collection_entry is called when production alter_backup_collection_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_backup_collection_entry(ctx *Alter_backup_collection_entryContext) {} - -// ExitAlter_backup_collection_entry is called when production alter_backup_collection_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_backup_collection_entry(ctx *Alter_backup_collection_entryContext) {} - -// EnterBackup_collection is called when production backup_collection is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBackup_collection(ctx *Backup_collectionContext) {} - -// ExitBackup_collection is called when production backup_collection is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBackup_collection(ctx *Backup_collectionContext) {} - -// EnterBackup_collection_settings is called when production backup_collection_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBackup_collection_settings(ctx *Backup_collection_settingsContext) {} - -// ExitBackup_collection_settings is called when production backup_collection_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBackup_collection_settings(ctx *Backup_collection_settingsContext) {} - -// EnterBackup_collection_settings_entry is called when production backup_collection_settings_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBackup_collection_settings_entry(ctx *Backup_collection_settings_entryContext) {} - -// ExitBackup_collection_settings_entry is called when production backup_collection_settings_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBackup_collection_settings_entry(ctx *Backup_collection_settings_entryContext) {} - -// EnterBackup_stmt is called when production backup_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBackup_stmt(ctx *Backup_stmtContext) {} - -// ExitBackup_stmt is called when production backup_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBackup_stmt(ctx *Backup_stmtContext) {} - -// EnterRestore_stmt is called when production restore_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRestore_stmt(ctx *Restore_stmtContext) {} - -// ExitRestore_stmt is called when production restore_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRestore_stmt(ctx *Restore_stmtContext) {} - -// EnterTable_inherits is called when production table_inherits is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_inherits(ctx *Table_inheritsContext) {} - -// ExitTable_inherits is called when production table_inherits is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_inherits(ctx *Table_inheritsContext) {} - -// EnterTable_partition_by is called when production table_partition_by is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_partition_by(ctx *Table_partition_byContext) {} - -// ExitTable_partition_by is called when production table_partition_by is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_partition_by(ctx *Table_partition_byContext) {} - -// EnterWith_table_settings is called when production with_table_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWith_table_settings(ctx *With_table_settingsContext) {} - -// ExitWith_table_settings is called when production with_table_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWith_table_settings(ctx *With_table_settingsContext) {} - -// EnterTable_tablestore is called when production table_tablestore is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_tablestore(ctx *Table_tablestoreContext) {} - -// ExitTable_tablestore is called when production table_tablestore is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_tablestore(ctx *Table_tablestoreContext) {} - -// EnterTable_settings_entry is called when production table_settings_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_settings_entry(ctx *Table_settings_entryContext) {} - -// ExitTable_settings_entry is called when production table_settings_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_settings_entry(ctx *Table_settings_entryContext) {} - -// EnterTable_as_source is called when production table_as_source is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_as_source(ctx *Table_as_sourceContext) {} - -// ExitTable_as_source is called when production table_as_source is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_as_source(ctx *Table_as_sourceContext) {} - -// EnterAlter_table_stmt is called when production alter_table_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_stmt(ctx *Alter_table_stmtContext) {} - -// ExitAlter_table_stmt is called when production alter_table_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_stmt(ctx *Alter_table_stmtContext) {} - -// EnterAlter_table_action is called when production alter_table_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_action(ctx *Alter_table_actionContext) {} - -// ExitAlter_table_action is called when production alter_table_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_action(ctx *Alter_table_actionContext) {} - -// EnterAlter_external_table_stmt is called when production alter_external_table_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_external_table_stmt(ctx *Alter_external_table_stmtContext) {} - -// ExitAlter_external_table_stmt is called when production alter_external_table_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_external_table_stmt(ctx *Alter_external_table_stmtContext) {} - -// EnterAlter_external_table_action is called when production alter_external_table_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_external_table_action(ctx *Alter_external_table_actionContext) {} - -// ExitAlter_external_table_action is called when production alter_external_table_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_external_table_action(ctx *Alter_external_table_actionContext) {} - -// EnterAlter_table_store_stmt is called when production alter_table_store_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_store_stmt(ctx *Alter_table_store_stmtContext) {} - -// ExitAlter_table_store_stmt is called when production alter_table_store_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_store_stmt(ctx *Alter_table_store_stmtContext) {} - -// EnterAlter_table_store_action is called when production alter_table_store_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_store_action(ctx *Alter_table_store_actionContext) {} - -// ExitAlter_table_store_action is called when production alter_table_store_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_store_action(ctx *Alter_table_store_actionContext) {} - -// EnterAlter_table_add_column is called when production alter_table_add_column is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_add_column(ctx *Alter_table_add_columnContext) {} - -// ExitAlter_table_add_column is called when production alter_table_add_column is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_add_column(ctx *Alter_table_add_columnContext) {} - -// EnterAlter_table_drop_column is called when production alter_table_drop_column is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_drop_column(ctx *Alter_table_drop_columnContext) {} - -// ExitAlter_table_drop_column is called when production alter_table_drop_column is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_drop_column(ctx *Alter_table_drop_columnContext) {} - -// EnterAlter_table_alter_column is called when production alter_table_alter_column is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_alter_column(ctx *Alter_table_alter_columnContext) {} - -// ExitAlter_table_alter_column is called when production alter_table_alter_column is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_alter_column(ctx *Alter_table_alter_columnContext) {} - -// EnterAlter_table_alter_column_drop_not_null is called when production alter_table_alter_column_drop_not_null is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_alter_column_drop_not_null(ctx *Alter_table_alter_column_drop_not_nullContext) {} - -// ExitAlter_table_alter_column_drop_not_null is called when production alter_table_alter_column_drop_not_null is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_alter_column_drop_not_null(ctx *Alter_table_alter_column_drop_not_nullContext) {} - -// EnterAlter_table_add_column_family is called when production alter_table_add_column_family is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_add_column_family(ctx *Alter_table_add_column_familyContext) {} - -// ExitAlter_table_add_column_family is called when production alter_table_add_column_family is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_add_column_family(ctx *Alter_table_add_column_familyContext) {} - -// EnterAlter_table_alter_column_family is called when production alter_table_alter_column_family is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_alter_column_family(ctx *Alter_table_alter_column_familyContext) {} - -// ExitAlter_table_alter_column_family is called when production alter_table_alter_column_family is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_alter_column_family(ctx *Alter_table_alter_column_familyContext) {} - -// EnterAlter_table_set_table_setting_uncompat is called when production alter_table_set_table_setting_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_set_table_setting_uncompat(ctx *Alter_table_set_table_setting_uncompatContext) {} - -// ExitAlter_table_set_table_setting_uncompat is called when production alter_table_set_table_setting_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_set_table_setting_uncompat(ctx *Alter_table_set_table_setting_uncompatContext) {} - -// EnterAlter_table_set_table_setting_compat is called when production alter_table_set_table_setting_compat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_set_table_setting_compat(ctx *Alter_table_set_table_setting_compatContext) {} - -// ExitAlter_table_set_table_setting_compat is called when production alter_table_set_table_setting_compat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_set_table_setting_compat(ctx *Alter_table_set_table_setting_compatContext) {} - -// EnterAlter_table_reset_table_setting is called when production alter_table_reset_table_setting is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_reset_table_setting(ctx *Alter_table_reset_table_settingContext) {} - -// ExitAlter_table_reset_table_setting is called when production alter_table_reset_table_setting is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_reset_table_setting(ctx *Alter_table_reset_table_settingContext) {} - -// EnterAlter_table_add_index is called when production alter_table_add_index is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_add_index(ctx *Alter_table_add_indexContext) {} - -// ExitAlter_table_add_index is called when production alter_table_add_index is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_add_index(ctx *Alter_table_add_indexContext) {} - -// EnterAlter_table_drop_index is called when production alter_table_drop_index is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_drop_index(ctx *Alter_table_drop_indexContext) {} - -// ExitAlter_table_drop_index is called when production alter_table_drop_index is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_drop_index(ctx *Alter_table_drop_indexContext) {} - -// EnterAlter_table_rename_to is called when production alter_table_rename_to is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_rename_to(ctx *Alter_table_rename_toContext) {} - -// ExitAlter_table_rename_to is called when production alter_table_rename_to is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_rename_to(ctx *Alter_table_rename_toContext) {} - -// EnterAlter_table_rename_index_to is called when production alter_table_rename_index_to is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_rename_index_to(ctx *Alter_table_rename_index_toContext) {} - -// ExitAlter_table_rename_index_to is called when production alter_table_rename_index_to is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_rename_index_to(ctx *Alter_table_rename_index_toContext) {} - -// EnterAlter_table_add_changefeed is called when production alter_table_add_changefeed is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_add_changefeed(ctx *Alter_table_add_changefeedContext) {} - -// ExitAlter_table_add_changefeed is called when production alter_table_add_changefeed is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_add_changefeed(ctx *Alter_table_add_changefeedContext) {} - -// EnterAlter_table_alter_changefeed is called when production alter_table_alter_changefeed is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_alter_changefeed(ctx *Alter_table_alter_changefeedContext) {} - -// ExitAlter_table_alter_changefeed is called when production alter_table_alter_changefeed is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_alter_changefeed(ctx *Alter_table_alter_changefeedContext) {} - -// EnterAlter_table_drop_changefeed is called when production alter_table_drop_changefeed is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_drop_changefeed(ctx *Alter_table_drop_changefeedContext) {} - -// ExitAlter_table_drop_changefeed is called when production alter_table_drop_changefeed is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_drop_changefeed(ctx *Alter_table_drop_changefeedContext) {} - -// EnterAlter_table_alter_index is called when production alter_table_alter_index is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_alter_index(ctx *Alter_table_alter_indexContext) {} - -// ExitAlter_table_alter_index is called when production alter_table_alter_index is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_alter_index(ctx *Alter_table_alter_indexContext) {} - -// EnterColumn_schema is called when production column_schema is entered. -func (s *BaseYQLv1Antlr4Listener) EnterColumn_schema(ctx *Column_schemaContext) {} - -// ExitColumn_schema is called when production column_schema is exited. -func (s *BaseYQLv1Antlr4Listener) ExitColumn_schema(ctx *Column_schemaContext) {} - -// EnterFamily_relation is called when production family_relation is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFamily_relation(ctx *Family_relationContext) {} - -// ExitFamily_relation is called when production family_relation is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFamily_relation(ctx *Family_relationContext) {} - -// EnterOpt_column_constraints is called when production opt_column_constraints is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOpt_column_constraints(ctx *Opt_column_constraintsContext) {} - -// ExitOpt_column_constraints is called when production opt_column_constraints is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOpt_column_constraints(ctx *Opt_column_constraintsContext) {} - -// EnterColumn_order_by_specification is called when production column_order_by_specification is entered. -func (s *BaseYQLv1Antlr4Listener) EnterColumn_order_by_specification(ctx *Column_order_by_specificationContext) {} - -// ExitColumn_order_by_specification is called when production column_order_by_specification is exited. -func (s *BaseYQLv1Antlr4Listener) ExitColumn_order_by_specification(ctx *Column_order_by_specificationContext) {} - -// EnterTable_constraint is called when production table_constraint is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_constraint(ctx *Table_constraintContext) {} - -// ExitTable_constraint is called when production table_constraint is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_constraint(ctx *Table_constraintContext) {} - -// EnterTable_index is called when production table_index is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_index(ctx *Table_indexContext) {} - -// ExitTable_index is called when production table_index is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_index(ctx *Table_indexContext) {} - -// EnterTable_index_type is called when production table_index_type is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_index_type(ctx *Table_index_typeContext) {} - -// ExitTable_index_type is called when production table_index_type is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_index_type(ctx *Table_index_typeContext) {} - -// EnterGlobal_index is called when production global_index is entered. -func (s *BaseYQLv1Antlr4Listener) EnterGlobal_index(ctx *Global_indexContext) {} - -// ExitGlobal_index is called when production global_index is exited. -func (s *BaseYQLv1Antlr4Listener) ExitGlobal_index(ctx *Global_indexContext) {} - -// EnterLocal_index is called when production local_index is entered. -func (s *BaseYQLv1Antlr4Listener) EnterLocal_index(ctx *Local_indexContext) {} - -// ExitLocal_index is called when production local_index is exited. -func (s *BaseYQLv1Antlr4Listener) ExitLocal_index(ctx *Local_indexContext) {} - -// EnterIndex_subtype is called when production index_subtype is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIndex_subtype(ctx *Index_subtypeContext) {} - -// ExitIndex_subtype is called when production index_subtype is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIndex_subtype(ctx *Index_subtypeContext) {} - -// EnterWith_index_settings is called when production with_index_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWith_index_settings(ctx *With_index_settingsContext) {} - -// ExitWith_index_settings is called when production with_index_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWith_index_settings(ctx *With_index_settingsContext) {} - -// EnterIndex_setting_entry is called when production index_setting_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIndex_setting_entry(ctx *Index_setting_entryContext) {} - -// ExitIndex_setting_entry is called when production index_setting_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIndex_setting_entry(ctx *Index_setting_entryContext) {} - -// EnterIndex_setting_value is called when production index_setting_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIndex_setting_value(ctx *Index_setting_valueContext) {} - -// ExitIndex_setting_value is called when production index_setting_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIndex_setting_value(ctx *Index_setting_valueContext) {} - -// EnterChangefeed is called when production changefeed is entered. -func (s *BaseYQLv1Antlr4Listener) EnterChangefeed(ctx *ChangefeedContext) {} - -// ExitChangefeed is called when production changefeed is exited. -func (s *BaseYQLv1Antlr4Listener) ExitChangefeed(ctx *ChangefeedContext) {} - -// EnterChangefeed_settings is called when production changefeed_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterChangefeed_settings(ctx *Changefeed_settingsContext) {} - -// ExitChangefeed_settings is called when production changefeed_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitChangefeed_settings(ctx *Changefeed_settingsContext) {} - -// EnterChangefeed_settings_entry is called when production changefeed_settings_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterChangefeed_settings_entry(ctx *Changefeed_settings_entryContext) {} - -// ExitChangefeed_settings_entry is called when production changefeed_settings_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitChangefeed_settings_entry(ctx *Changefeed_settings_entryContext) {} - -// EnterChangefeed_setting_value is called when production changefeed_setting_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterChangefeed_setting_value(ctx *Changefeed_setting_valueContext) {} - -// ExitChangefeed_setting_value is called when production changefeed_setting_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitChangefeed_setting_value(ctx *Changefeed_setting_valueContext) {} - -// EnterChangefeed_alter_settings is called when production changefeed_alter_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterChangefeed_alter_settings(ctx *Changefeed_alter_settingsContext) {} - -// ExitChangefeed_alter_settings is called when production changefeed_alter_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitChangefeed_alter_settings(ctx *Changefeed_alter_settingsContext) {} - -// EnterAlter_table_setting_entry is called when production alter_table_setting_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_setting_entry(ctx *Alter_table_setting_entryContext) {} - -// ExitAlter_table_setting_entry is called when production alter_table_setting_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_setting_entry(ctx *Alter_table_setting_entryContext) {} - -// EnterTable_setting_value is called when production table_setting_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_setting_value(ctx *Table_setting_valueContext) {} - -// ExitTable_setting_value is called when production table_setting_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_setting_value(ctx *Table_setting_valueContext) {} - -// EnterTtl_tier_list is called when production ttl_tier_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTtl_tier_list(ctx *Ttl_tier_listContext) {} - -// ExitTtl_tier_list is called when production ttl_tier_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTtl_tier_list(ctx *Ttl_tier_listContext) {} - -// EnterTtl_tier_action is called when production ttl_tier_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTtl_tier_action(ctx *Ttl_tier_actionContext) {} - -// ExitTtl_tier_action is called when production ttl_tier_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTtl_tier_action(ctx *Ttl_tier_actionContext) {} - -// EnterFamily_entry is called when production family_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFamily_entry(ctx *Family_entryContext) {} - -// ExitFamily_entry is called when production family_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFamily_entry(ctx *Family_entryContext) {} - -// EnterFamily_settings is called when production family_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFamily_settings(ctx *Family_settingsContext) {} - -// ExitFamily_settings is called when production family_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFamily_settings(ctx *Family_settingsContext) {} - -// EnterFamily_settings_entry is called when production family_settings_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFamily_settings_entry(ctx *Family_settings_entryContext) {} - -// ExitFamily_settings_entry is called when production family_settings_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFamily_settings_entry(ctx *Family_settings_entryContext) {} - -// EnterFamily_setting_value is called when production family_setting_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFamily_setting_value(ctx *Family_setting_valueContext) {} - -// ExitFamily_setting_value is called when production family_setting_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFamily_setting_value(ctx *Family_setting_valueContext) {} - -// EnterSplit_boundaries is called when production split_boundaries is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSplit_boundaries(ctx *Split_boundariesContext) {} - -// ExitSplit_boundaries is called when production split_boundaries is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSplit_boundaries(ctx *Split_boundariesContext) {} - -// EnterLiteral_value_list is called when production literal_value_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterLiteral_value_list(ctx *Literal_value_listContext) {} - -// ExitLiteral_value_list is called when production literal_value_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitLiteral_value_list(ctx *Literal_value_listContext) {} - -// EnterAlter_table_alter_index_action is called when production alter_table_alter_index_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_table_alter_index_action(ctx *Alter_table_alter_index_actionContext) {} - -// ExitAlter_table_alter_index_action is called when production alter_table_alter_index_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_table_alter_index_action(ctx *Alter_table_alter_index_actionContext) {} - -// EnterDrop_table_stmt is called when production drop_table_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_table_stmt(ctx *Drop_table_stmtContext) {} - -// ExitDrop_table_stmt is called when production drop_table_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_table_stmt(ctx *Drop_table_stmtContext) {} - -// EnterCreate_user_stmt is called when production create_user_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_user_stmt(ctx *Create_user_stmtContext) {} - -// ExitCreate_user_stmt is called when production create_user_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_user_stmt(ctx *Create_user_stmtContext) {} - -// EnterAlter_user_stmt is called when production alter_user_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_user_stmt(ctx *Alter_user_stmtContext) {} - -// ExitAlter_user_stmt is called when production alter_user_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_user_stmt(ctx *Alter_user_stmtContext) {} - -// EnterCreate_group_stmt is called when production create_group_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_group_stmt(ctx *Create_group_stmtContext) {} - -// ExitCreate_group_stmt is called when production create_group_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_group_stmt(ctx *Create_group_stmtContext) {} - -// EnterAlter_group_stmt is called when production alter_group_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_group_stmt(ctx *Alter_group_stmtContext) {} - -// ExitAlter_group_stmt is called when production alter_group_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_group_stmt(ctx *Alter_group_stmtContext) {} - -// EnterDrop_role_stmt is called when production drop_role_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_role_stmt(ctx *Drop_role_stmtContext) {} - -// ExitDrop_role_stmt is called when production drop_role_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_role_stmt(ctx *Drop_role_stmtContext) {} - -// EnterRole_name is called when production role_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRole_name(ctx *Role_nameContext) {} - -// ExitRole_name is called when production role_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRole_name(ctx *Role_nameContext) {} - -// EnterCreate_user_option is called when production create_user_option is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_user_option(ctx *Create_user_optionContext) {} - -// ExitCreate_user_option is called when production create_user_option is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_user_option(ctx *Create_user_optionContext) {} - -// EnterPassword_option is called when production password_option is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPassword_option(ctx *Password_optionContext) {} - -// ExitPassword_option is called when production password_option is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPassword_option(ctx *Password_optionContext) {} - -// EnterLogin_option is called when production login_option is entered. -func (s *BaseYQLv1Antlr4Listener) EnterLogin_option(ctx *Login_optionContext) {} - -// ExitLogin_option is called when production login_option is exited. -func (s *BaseYQLv1Antlr4Listener) ExitLogin_option(ctx *Login_optionContext) {} - -// EnterGrant_permissions_stmt is called when production grant_permissions_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterGrant_permissions_stmt(ctx *Grant_permissions_stmtContext) {} - -// ExitGrant_permissions_stmt is called when production grant_permissions_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitGrant_permissions_stmt(ctx *Grant_permissions_stmtContext) {} - -// EnterRevoke_permissions_stmt is called when production revoke_permissions_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRevoke_permissions_stmt(ctx *Revoke_permissions_stmtContext) {} - -// ExitRevoke_permissions_stmt is called when production revoke_permissions_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRevoke_permissions_stmt(ctx *Revoke_permissions_stmtContext) {} - -// EnterPermission_id is called when production permission_id is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPermission_id(ctx *Permission_idContext) {} - -// ExitPermission_id is called when production permission_id is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPermission_id(ctx *Permission_idContext) {} - -// EnterPermission_name is called when production permission_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPermission_name(ctx *Permission_nameContext) {} - -// ExitPermission_name is called when production permission_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPermission_name(ctx *Permission_nameContext) {} - -// EnterPermission_name_target is called when production permission_name_target is entered. -func (s *BaseYQLv1Antlr4Listener) EnterPermission_name_target(ctx *Permission_name_targetContext) {} - -// ExitPermission_name_target is called when production permission_name_target is exited. -func (s *BaseYQLv1Antlr4Listener) ExitPermission_name_target(ctx *Permission_name_targetContext) {} - -// EnterCreate_resource_pool_stmt is called when production create_resource_pool_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_resource_pool_stmt(ctx *Create_resource_pool_stmtContext) {} - -// ExitCreate_resource_pool_stmt is called when production create_resource_pool_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_resource_pool_stmt(ctx *Create_resource_pool_stmtContext) {} - -// EnterAlter_resource_pool_stmt is called when production alter_resource_pool_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_resource_pool_stmt(ctx *Alter_resource_pool_stmtContext) {} - -// ExitAlter_resource_pool_stmt is called when production alter_resource_pool_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_resource_pool_stmt(ctx *Alter_resource_pool_stmtContext) {} - -// EnterAlter_resource_pool_action is called when production alter_resource_pool_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_resource_pool_action(ctx *Alter_resource_pool_actionContext) {} - -// ExitAlter_resource_pool_action is called when production alter_resource_pool_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_resource_pool_action(ctx *Alter_resource_pool_actionContext) {} - -// EnterDrop_resource_pool_stmt is called when production drop_resource_pool_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_resource_pool_stmt(ctx *Drop_resource_pool_stmtContext) {} - -// ExitDrop_resource_pool_stmt is called when production drop_resource_pool_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_resource_pool_stmt(ctx *Drop_resource_pool_stmtContext) {} - -// EnterCreate_resource_pool_classifier_stmt is called when production create_resource_pool_classifier_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_resource_pool_classifier_stmt(ctx *Create_resource_pool_classifier_stmtContext) {} - -// ExitCreate_resource_pool_classifier_stmt is called when production create_resource_pool_classifier_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_resource_pool_classifier_stmt(ctx *Create_resource_pool_classifier_stmtContext) {} - -// EnterAlter_resource_pool_classifier_stmt is called when production alter_resource_pool_classifier_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_resource_pool_classifier_stmt(ctx *Alter_resource_pool_classifier_stmtContext) {} - -// ExitAlter_resource_pool_classifier_stmt is called when production alter_resource_pool_classifier_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_resource_pool_classifier_stmt(ctx *Alter_resource_pool_classifier_stmtContext) {} - -// EnterAlter_resource_pool_classifier_action is called when production alter_resource_pool_classifier_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_resource_pool_classifier_action(ctx *Alter_resource_pool_classifier_actionContext) {} - -// ExitAlter_resource_pool_classifier_action is called when production alter_resource_pool_classifier_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_resource_pool_classifier_action(ctx *Alter_resource_pool_classifier_actionContext) {} - -// EnterDrop_resource_pool_classifier_stmt is called when production drop_resource_pool_classifier_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_resource_pool_classifier_stmt(ctx *Drop_resource_pool_classifier_stmtContext) {} - -// ExitDrop_resource_pool_classifier_stmt is called when production drop_resource_pool_classifier_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_resource_pool_classifier_stmt(ctx *Drop_resource_pool_classifier_stmtContext) {} - -// EnterCreate_replication_stmt is called when production create_replication_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_replication_stmt(ctx *Create_replication_stmtContext) {} - -// ExitCreate_replication_stmt is called when production create_replication_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_replication_stmt(ctx *Create_replication_stmtContext) {} - -// EnterReplication_target is called when production replication_target is entered. -func (s *BaseYQLv1Antlr4Listener) EnterReplication_target(ctx *Replication_targetContext) {} - -// ExitReplication_target is called when production replication_target is exited. -func (s *BaseYQLv1Antlr4Listener) ExitReplication_target(ctx *Replication_targetContext) {} - -// EnterReplication_settings is called when production replication_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterReplication_settings(ctx *Replication_settingsContext) {} - -// ExitReplication_settings is called when production replication_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitReplication_settings(ctx *Replication_settingsContext) {} - -// EnterReplication_settings_entry is called when production replication_settings_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterReplication_settings_entry(ctx *Replication_settings_entryContext) {} - -// ExitReplication_settings_entry is called when production replication_settings_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitReplication_settings_entry(ctx *Replication_settings_entryContext) {} - -// EnterAlter_replication_stmt is called when production alter_replication_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_replication_stmt(ctx *Alter_replication_stmtContext) {} - -// ExitAlter_replication_stmt is called when production alter_replication_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_replication_stmt(ctx *Alter_replication_stmtContext) {} - -// EnterAlter_replication_action is called when production alter_replication_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_replication_action(ctx *Alter_replication_actionContext) {} - -// ExitAlter_replication_action is called when production alter_replication_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_replication_action(ctx *Alter_replication_actionContext) {} - -// EnterAlter_replication_set_setting is called when production alter_replication_set_setting is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_replication_set_setting(ctx *Alter_replication_set_settingContext) {} - -// ExitAlter_replication_set_setting is called when production alter_replication_set_setting is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_replication_set_setting(ctx *Alter_replication_set_settingContext) {} - -// EnterDrop_replication_stmt is called when production drop_replication_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_replication_stmt(ctx *Drop_replication_stmtContext) {} - -// ExitDrop_replication_stmt is called when production drop_replication_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_replication_stmt(ctx *Drop_replication_stmtContext) {} - -// EnterAction_or_subquery_args is called when production action_or_subquery_args is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAction_or_subquery_args(ctx *Action_or_subquery_argsContext) {} - -// ExitAction_or_subquery_args is called when production action_or_subquery_args is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAction_or_subquery_args(ctx *Action_or_subquery_argsContext) {} - -// EnterDefine_action_or_subquery_stmt is called when production define_action_or_subquery_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDefine_action_or_subquery_stmt(ctx *Define_action_or_subquery_stmtContext) {} - -// ExitDefine_action_or_subquery_stmt is called when production define_action_or_subquery_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDefine_action_or_subquery_stmt(ctx *Define_action_or_subquery_stmtContext) {} - -// EnterDefine_action_or_subquery_body is called when production define_action_or_subquery_body is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDefine_action_or_subquery_body(ctx *Define_action_or_subquery_bodyContext) {} - -// ExitDefine_action_or_subquery_body is called when production define_action_or_subquery_body is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDefine_action_or_subquery_body(ctx *Define_action_or_subquery_bodyContext) {} - -// EnterIf_stmt is called when production if_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIf_stmt(ctx *If_stmtContext) {} - -// ExitIf_stmt is called when production if_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIf_stmt(ctx *If_stmtContext) {} - -// EnterFor_stmt is called when production for_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFor_stmt(ctx *For_stmtContext) {} - -// ExitFor_stmt is called when production for_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFor_stmt(ctx *For_stmtContext) {} - -// EnterTable_ref is called when production table_ref is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_ref(ctx *Table_refContext) {} - -// ExitTable_ref is called when production table_ref is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_ref(ctx *Table_refContext) {} - -// EnterTable_key is called when production table_key is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_key(ctx *Table_keyContext) {} - -// ExitTable_key is called when production table_key is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_key(ctx *Table_keyContext) {} - -// EnterTable_arg is called when production table_arg is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_arg(ctx *Table_argContext) {} - -// ExitTable_arg is called when production table_arg is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_arg(ctx *Table_argContext) {} - -// EnterTable_hints is called when production table_hints is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_hints(ctx *Table_hintsContext) {} - -// ExitTable_hints is called when production table_hints is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_hints(ctx *Table_hintsContext) {} - -// EnterTable_hint is called when production table_hint is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTable_hint(ctx *Table_hintContext) {} - -// ExitTable_hint is called when production table_hint is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTable_hint(ctx *Table_hintContext) {} - -// EnterObject_ref is called when production object_ref is entered. -func (s *BaseYQLv1Antlr4Listener) EnterObject_ref(ctx *Object_refContext) {} - -// ExitObject_ref is called when production object_ref is exited. -func (s *BaseYQLv1Antlr4Listener) ExitObject_ref(ctx *Object_refContext) {} - -// EnterSimple_table_ref_core is called when production simple_table_ref_core is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSimple_table_ref_core(ctx *Simple_table_ref_coreContext) {} - -// ExitSimple_table_ref_core is called when production simple_table_ref_core is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSimple_table_ref_core(ctx *Simple_table_ref_coreContext) {} - -// EnterSimple_table_ref is called when production simple_table_ref is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSimple_table_ref(ctx *Simple_table_refContext) {} - -// ExitSimple_table_ref is called when production simple_table_ref is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSimple_table_ref(ctx *Simple_table_refContext) {} - -// EnterInto_simple_table_ref is called when production into_simple_table_ref is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInto_simple_table_ref(ctx *Into_simple_table_refContext) {} - -// ExitInto_simple_table_ref is called when production into_simple_table_ref is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInto_simple_table_ref(ctx *Into_simple_table_refContext) {} - -// EnterDelete_stmt is called when production delete_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDelete_stmt(ctx *Delete_stmtContext) {} - -// ExitDelete_stmt is called when production delete_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDelete_stmt(ctx *Delete_stmtContext) {} - -// EnterUpdate_stmt is called when production update_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUpdate_stmt(ctx *Update_stmtContext) {} - -// ExitUpdate_stmt is called when production update_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUpdate_stmt(ctx *Update_stmtContext) {} - -// EnterSet_clause_choice is called when production set_clause_choice is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSet_clause_choice(ctx *Set_clause_choiceContext) {} - -// ExitSet_clause_choice is called when production set_clause_choice is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSet_clause_choice(ctx *Set_clause_choiceContext) {} - -// EnterSet_clause_list is called when production set_clause_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSet_clause_list(ctx *Set_clause_listContext) {} - -// ExitSet_clause_list is called when production set_clause_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSet_clause_list(ctx *Set_clause_listContext) {} - -// EnterSet_clause is called when production set_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSet_clause(ctx *Set_clauseContext) {} - -// ExitSet_clause is called when production set_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSet_clause(ctx *Set_clauseContext) {} - -// EnterSet_target is called when production set_target is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSet_target(ctx *Set_targetContext) {} - -// ExitSet_target is called when production set_target is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSet_target(ctx *Set_targetContext) {} - -// EnterMultiple_column_assignment is called when production multiple_column_assignment is entered. -func (s *BaseYQLv1Antlr4Listener) EnterMultiple_column_assignment(ctx *Multiple_column_assignmentContext) {} - -// ExitMultiple_column_assignment is called when production multiple_column_assignment is exited. -func (s *BaseYQLv1Antlr4Listener) ExitMultiple_column_assignment(ctx *Multiple_column_assignmentContext) {} - -// EnterSet_target_list is called when production set_target_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSet_target_list(ctx *Set_target_listContext) {} - -// ExitSet_target_list is called when production set_target_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSet_target_list(ctx *Set_target_listContext) {} - -// EnterCreate_topic_stmt is called when production create_topic_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_topic_stmt(ctx *Create_topic_stmtContext) {} - -// ExitCreate_topic_stmt is called when production create_topic_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_topic_stmt(ctx *Create_topic_stmtContext) {} - -// EnterCreate_topic_entries is called when production create_topic_entries is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_topic_entries(ctx *Create_topic_entriesContext) {} - -// ExitCreate_topic_entries is called when production create_topic_entries is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_topic_entries(ctx *Create_topic_entriesContext) {} - -// EnterCreate_topic_entry is called when production create_topic_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCreate_topic_entry(ctx *Create_topic_entryContext) {} - -// ExitCreate_topic_entry is called when production create_topic_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCreate_topic_entry(ctx *Create_topic_entryContext) {} - -// EnterWith_topic_settings is called when production with_topic_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWith_topic_settings(ctx *With_topic_settingsContext) {} - -// ExitWith_topic_settings is called when production with_topic_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWith_topic_settings(ctx *With_topic_settingsContext) {} - -// EnterAlter_topic_stmt is called when production alter_topic_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_stmt(ctx *Alter_topic_stmtContext) {} - -// ExitAlter_topic_stmt is called when production alter_topic_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_stmt(ctx *Alter_topic_stmtContext) {} - -// EnterAlter_topic_action is called when production alter_topic_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_action(ctx *Alter_topic_actionContext) {} - -// ExitAlter_topic_action is called when production alter_topic_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_action(ctx *Alter_topic_actionContext) {} - -// EnterAlter_topic_add_consumer is called when production alter_topic_add_consumer is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_add_consumer(ctx *Alter_topic_add_consumerContext) {} - -// ExitAlter_topic_add_consumer is called when production alter_topic_add_consumer is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_add_consumer(ctx *Alter_topic_add_consumerContext) {} - -// EnterTopic_create_consumer_entry is called when production topic_create_consumer_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_create_consumer_entry(ctx *Topic_create_consumer_entryContext) {} - -// ExitTopic_create_consumer_entry is called when production topic_create_consumer_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_create_consumer_entry(ctx *Topic_create_consumer_entryContext) {} - -// EnterAlter_topic_alter_consumer is called when production alter_topic_alter_consumer is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_alter_consumer(ctx *Alter_topic_alter_consumerContext) {} - -// ExitAlter_topic_alter_consumer is called when production alter_topic_alter_consumer is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_alter_consumer(ctx *Alter_topic_alter_consumerContext) {} - -// EnterAlter_topic_alter_consumer_entry is called when production alter_topic_alter_consumer_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_alter_consumer_entry(ctx *Alter_topic_alter_consumer_entryContext) {} - -// ExitAlter_topic_alter_consumer_entry is called when production alter_topic_alter_consumer_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_alter_consumer_entry(ctx *Alter_topic_alter_consumer_entryContext) {} - -// EnterAlter_topic_drop_consumer is called when production alter_topic_drop_consumer is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_drop_consumer(ctx *Alter_topic_drop_consumerContext) {} - -// ExitAlter_topic_drop_consumer is called when production alter_topic_drop_consumer is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_drop_consumer(ctx *Alter_topic_drop_consumerContext) {} - -// EnterTopic_alter_consumer_set is called when production topic_alter_consumer_set is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_alter_consumer_set(ctx *Topic_alter_consumer_setContext) {} - -// ExitTopic_alter_consumer_set is called when production topic_alter_consumer_set is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_alter_consumer_set(ctx *Topic_alter_consumer_setContext) {} - -// EnterTopic_alter_consumer_reset is called when production topic_alter_consumer_reset is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_alter_consumer_reset(ctx *Topic_alter_consumer_resetContext) {} - -// ExitTopic_alter_consumer_reset is called when production topic_alter_consumer_reset is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_alter_consumer_reset(ctx *Topic_alter_consumer_resetContext) {} - -// EnterAlter_topic_set_settings is called when production alter_topic_set_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_set_settings(ctx *Alter_topic_set_settingsContext) {} - -// ExitAlter_topic_set_settings is called when production alter_topic_set_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_set_settings(ctx *Alter_topic_set_settingsContext) {} - -// EnterAlter_topic_reset_settings is called when production alter_topic_reset_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_topic_reset_settings(ctx *Alter_topic_reset_settingsContext) {} - -// ExitAlter_topic_reset_settings is called when production alter_topic_reset_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_topic_reset_settings(ctx *Alter_topic_reset_settingsContext) {} - -// EnterDrop_topic_stmt is called when production drop_topic_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterDrop_topic_stmt(ctx *Drop_topic_stmtContext) {} - -// ExitDrop_topic_stmt is called when production drop_topic_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitDrop_topic_stmt(ctx *Drop_topic_stmtContext) {} - -// EnterTopic_settings is called when production topic_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_settings(ctx *Topic_settingsContext) {} - -// ExitTopic_settings is called when production topic_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_settings(ctx *Topic_settingsContext) {} - -// EnterTopic_settings_entry is called when production topic_settings_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_settings_entry(ctx *Topic_settings_entryContext) {} - -// ExitTopic_settings_entry is called when production topic_settings_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_settings_entry(ctx *Topic_settings_entryContext) {} - -// EnterTopic_setting_value is called when production topic_setting_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_setting_value(ctx *Topic_setting_valueContext) {} - -// ExitTopic_setting_value is called when production topic_setting_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_setting_value(ctx *Topic_setting_valueContext) {} - -// EnterTopic_consumer_with_settings is called when production topic_consumer_with_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_consumer_with_settings(ctx *Topic_consumer_with_settingsContext) {} - -// ExitTopic_consumer_with_settings is called when production topic_consumer_with_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_consumer_with_settings(ctx *Topic_consumer_with_settingsContext) {} - -// EnterTopic_consumer_settings is called when production topic_consumer_settings is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_consumer_settings(ctx *Topic_consumer_settingsContext) {} - -// ExitTopic_consumer_settings is called when production topic_consumer_settings is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_consumer_settings(ctx *Topic_consumer_settingsContext) {} - -// EnterTopic_consumer_settings_entry is called when production topic_consumer_settings_entry is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_consumer_settings_entry(ctx *Topic_consumer_settings_entryContext) {} - -// ExitTopic_consumer_settings_entry is called when production topic_consumer_settings_entry is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_consumer_settings_entry(ctx *Topic_consumer_settings_entryContext) {} - -// EnterTopic_consumer_setting_value is called when production topic_consumer_setting_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_consumer_setting_value(ctx *Topic_consumer_setting_valueContext) {} - -// ExitTopic_consumer_setting_value is called when production topic_consumer_setting_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_consumer_setting_value(ctx *Topic_consumer_setting_valueContext) {} - -// EnterTopic_ref is called when production topic_ref is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_ref(ctx *Topic_refContext) {} - -// ExitTopic_ref is called when production topic_ref is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_ref(ctx *Topic_refContext) {} - -// EnterTopic_consumer_ref is called when production topic_consumer_ref is entered. -func (s *BaseYQLv1Antlr4Listener) EnterTopic_consumer_ref(ctx *Topic_consumer_refContext) {} - -// ExitTopic_consumer_ref is called when production topic_consumer_ref is exited. -func (s *BaseYQLv1Antlr4Listener) ExitTopic_consumer_ref(ctx *Topic_consumer_refContext) {} - -// EnterNull_treatment is called when production null_treatment is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNull_treatment(ctx *Null_treatmentContext) {} - -// ExitNull_treatment is called when production null_treatment is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNull_treatment(ctx *Null_treatmentContext) {} - -// EnterFilter_clause is called when production filter_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterFilter_clause(ctx *Filter_clauseContext) {} - -// ExitFilter_clause is called when production filter_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitFilter_clause(ctx *Filter_clauseContext) {} - -// EnterWindow_name_or_specification is called when production window_name_or_specification is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_name_or_specification(ctx *Window_name_or_specificationContext) {} - -// ExitWindow_name_or_specification is called when production window_name_or_specification is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_name_or_specification(ctx *Window_name_or_specificationContext) {} - -// EnterWindow_name is called when production window_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_name(ctx *Window_nameContext) {} - -// ExitWindow_name is called when production window_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_name(ctx *Window_nameContext) {} - -// EnterWindow_clause is called when production window_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_clause(ctx *Window_clauseContext) {} - -// ExitWindow_clause is called when production window_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_clause(ctx *Window_clauseContext) {} - -// EnterWindow_definition_list is called when production window_definition_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_definition_list(ctx *Window_definition_listContext) {} - -// ExitWindow_definition_list is called when production window_definition_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_definition_list(ctx *Window_definition_listContext) {} - -// EnterWindow_definition is called when production window_definition is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_definition(ctx *Window_definitionContext) {} - -// ExitWindow_definition is called when production window_definition is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_definition(ctx *Window_definitionContext) {} - -// EnterNew_window_name is called when production new_window_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNew_window_name(ctx *New_window_nameContext) {} - -// ExitNew_window_name is called when production new_window_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNew_window_name(ctx *New_window_nameContext) {} - -// EnterWindow_specification is called when production window_specification is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_specification(ctx *Window_specificationContext) {} - -// ExitWindow_specification is called when production window_specification is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_specification(ctx *Window_specificationContext) {} - -// EnterWindow_specification_details is called when production window_specification_details is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_specification_details(ctx *Window_specification_detailsContext) {} - -// ExitWindow_specification_details is called when production window_specification_details is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_specification_details(ctx *Window_specification_detailsContext) {} - -// EnterExisting_window_name is called when production existing_window_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterExisting_window_name(ctx *Existing_window_nameContext) {} - -// ExitExisting_window_name is called when production existing_window_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitExisting_window_name(ctx *Existing_window_nameContext) {} - -// EnterWindow_partition_clause is called when production window_partition_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_partition_clause(ctx *Window_partition_clauseContext) {} - -// ExitWindow_partition_clause is called when production window_partition_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_partition_clause(ctx *Window_partition_clauseContext) {} - -// EnterWindow_order_clause is called when production window_order_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_order_clause(ctx *Window_order_clauseContext) {} - -// ExitWindow_order_clause is called when production window_order_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_order_clause(ctx *Window_order_clauseContext) {} - -// EnterWindow_frame_clause is called when production window_frame_clause is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_frame_clause(ctx *Window_frame_clauseContext) {} - -// ExitWindow_frame_clause is called when production window_frame_clause is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_frame_clause(ctx *Window_frame_clauseContext) {} - -// EnterWindow_frame_units is called when production window_frame_units is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_frame_units(ctx *Window_frame_unitsContext) {} - -// ExitWindow_frame_units is called when production window_frame_units is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_frame_units(ctx *Window_frame_unitsContext) {} - -// EnterWindow_frame_extent is called when production window_frame_extent is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_frame_extent(ctx *Window_frame_extentContext) {} - -// ExitWindow_frame_extent is called when production window_frame_extent is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_frame_extent(ctx *Window_frame_extentContext) {} - -// EnterWindow_frame_between is called when production window_frame_between is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_frame_between(ctx *Window_frame_betweenContext) {} - -// ExitWindow_frame_between is called when production window_frame_between is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_frame_between(ctx *Window_frame_betweenContext) {} - -// EnterWindow_frame_bound is called when production window_frame_bound is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_frame_bound(ctx *Window_frame_boundContext) {} - -// ExitWindow_frame_bound is called when production window_frame_bound is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_frame_bound(ctx *Window_frame_boundContext) {} - -// EnterWindow_frame_exclusion is called when production window_frame_exclusion is entered. -func (s *BaseYQLv1Antlr4Listener) EnterWindow_frame_exclusion(ctx *Window_frame_exclusionContext) {} - -// ExitWindow_frame_exclusion is called when production window_frame_exclusion is exited. -func (s *BaseYQLv1Antlr4Listener) ExitWindow_frame_exclusion(ctx *Window_frame_exclusionContext) {} - -// EnterUse_stmt is called when production use_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterUse_stmt(ctx *Use_stmtContext) {} - -// ExitUse_stmt is called when production use_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitUse_stmt(ctx *Use_stmtContext) {} - -// EnterSubselect_stmt is called when production subselect_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterSubselect_stmt(ctx *Subselect_stmtContext) {} - -// ExitSubselect_stmt is called when production subselect_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitSubselect_stmt(ctx *Subselect_stmtContext) {} - -// EnterNamed_nodes_stmt is called when production named_nodes_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterNamed_nodes_stmt(ctx *Named_nodes_stmtContext) {} - -// ExitNamed_nodes_stmt is called when production named_nodes_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitNamed_nodes_stmt(ctx *Named_nodes_stmtContext) {} - -// EnterCommit_stmt is called when production commit_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCommit_stmt(ctx *Commit_stmtContext) {} - -// ExitCommit_stmt is called when production commit_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCommit_stmt(ctx *Commit_stmtContext) {} - -// EnterRollback_stmt is called when production rollback_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterRollback_stmt(ctx *Rollback_stmtContext) {} - -// ExitRollback_stmt is called when production rollback_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitRollback_stmt(ctx *Rollback_stmtContext) {} - -// EnterAnalyze_table is called when production analyze_table is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAnalyze_table(ctx *Analyze_tableContext) {} - -// ExitAnalyze_table is called when production analyze_table is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAnalyze_table(ctx *Analyze_tableContext) {} - -// EnterAnalyze_table_list is called when production analyze_table_list is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAnalyze_table_list(ctx *Analyze_table_listContext) {} - -// ExitAnalyze_table_list is called when production analyze_table_list is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAnalyze_table_list(ctx *Analyze_table_listContext) {} - -// EnterAnalyze_stmt is called when production analyze_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAnalyze_stmt(ctx *Analyze_stmtContext) {} - -// ExitAnalyze_stmt is called when production analyze_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAnalyze_stmt(ctx *Analyze_stmtContext) {} - -// EnterAlter_sequence_stmt is called when production alter_sequence_stmt is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_sequence_stmt(ctx *Alter_sequence_stmtContext) {} - -// ExitAlter_sequence_stmt is called when production alter_sequence_stmt is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_sequence_stmt(ctx *Alter_sequence_stmtContext) {} - -// EnterAlter_sequence_action is called when production alter_sequence_action is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAlter_sequence_action(ctx *Alter_sequence_actionContext) {} - -// ExitAlter_sequence_action is called when production alter_sequence_action is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAlter_sequence_action(ctx *Alter_sequence_actionContext) {} - -// EnterIdentifier is called when production identifier is entered. -func (s *BaseYQLv1Antlr4Listener) EnterIdentifier(ctx *IdentifierContext) {} - -// ExitIdentifier is called when production identifier is exited. -func (s *BaseYQLv1Antlr4Listener) ExitIdentifier(ctx *IdentifierContext) {} - -// EnterId is called when production id is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId(ctx *IdContext) {} - -// ExitId is called when production id is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId(ctx *IdContext) {} - -// EnterId_schema is called when production id_schema is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_schema(ctx *Id_schemaContext) {} - -// ExitId_schema is called when production id_schema is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_schema(ctx *Id_schemaContext) {} - -// EnterId_expr is called when production id_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_expr(ctx *Id_exprContext) {} - -// ExitId_expr is called when production id_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_expr(ctx *Id_exprContext) {} - -// EnterId_expr_in is called when production id_expr_in is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_expr_in(ctx *Id_expr_inContext) {} - -// ExitId_expr_in is called when production id_expr_in is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_expr_in(ctx *Id_expr_inContext) {} - -// EnterId_window is called when production id_window is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_window(ctx *Id_windowContext) {} - -// ExitId_window is called when production id_window is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_window(ctx *Id_windowContext) {} - -// EnterId_table is called when production id_table is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_table(ctx *Id_tableContext) {} - -// ExitId_table is called when production id_table is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_table(ctx *Id_tableContext) {} - -// EnterId_without is called when production id_without is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_without(ctx *Id_withoutContext) {} - -// ExitId_without is called when production id_without is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_without(ctx *Id_withoutContext) {} - -// EnterId_hint is called when production id_hint is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_hint(ctx *Id_hintContext) {} - -// ExitId_hint is called when production id_hint is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_hint(ctx *Id_hintContext) {} - -// EnterId_as_compat is called when production id_as_compat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_as_compat(ctx *Id_as_compatContext) {} - -// ExitId_as_compat is called when production id_as_compat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_as_compat(ctx *Id_as_compatContext) {} - -// EnterAn_id is called when production an_id is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id(ctx *An_idContext) {} - -// ExitAn_id is called when production an_id is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id(ctx *An_idContext) {} - -// EnterAn_id_or_type is called when production an_id_or_type is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_or_type(ctx *An_id_or_typeContext) {} - -// ExitAn_id_or_type is called when production an_id_or_type is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_or_type(ctx *An_id_or_typeContext) {} - -// EnterAn_id_schema is called when production an_id_schema is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_schema(ctx *An_id_schemaContext) {} - -// ExitAn_id_schema is called when production an_id_schema is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_schema(ctx *An_id_schemaContext) {} - -// EnterAn_id_expr is called when production an_id_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_expr(ctx *An_id_exprContext) {} - -// ExitAn_id_expr is called when production an_id_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_expr(ctx *An_id_exprContext) {} - -// EnterAn_id_expr_in is called when production an_id_expr_in is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_expr_in(ctx *An_id_expr_inContext) {} - -// ExitAn_id_expr_in is called when production an_id_expr_in is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_expr_in(ctx *An_id_expr_inContext) {} - -// EnterAn_id_window is called when production an_id_window is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_window(ctx *An_id_windowContext) {} - -// ExitAn_id_window is called when production an_id_window is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_window(ctx *An_id_windowContext) {} - -// EnterAn_id_table is called when production an_id_table is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_table(ctx *An_id_tableContext) {} - -// ExitAn_id_table is called when production an_id_table is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_table(ctx *An_id_tableContext) {} - -// EnterAn_id_without is called when production an_id_without is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_without(ctx *An_id_withoutContext) {} - -// ExitAn_id_without is called when production an_id_without is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_without(ctx *An_id_withoutContext) {} - -// EnterAn_id_hint is called when production an_id_hint is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_hint(ctx *An_id_hintContext) {} - -// ExitAn_id_hint is called when production an_id_hint is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_hint(ctx *An_id_hintContext) {} - -// EnterAn_id_pure is called when production an_id_pure is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_pure(ctx *An_id_pureContext) {} - -// ExitAn_id_pure is called when production an_id_pure is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_pure(ctx *An_id_pureContext) {} - -// EnterAn_id_as_compat is called when production an_id_as_compat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterAn_id_as_compat(ctx *An_id_as_compatContext) {} - -// ExitAn_id_as_compat is called when production an_id_as_compat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitAn_id_as_compat(ctx *An_id_as_compatContext) {} - -// EnterView_name is called when production view_name is entered. -func (s *BaseYQLv1Antlr4Listener) EnterView_name(ctx *View_nameContext) {} - -// ExitView_name is called when production view_name is exited. -func (s *BaseYQLv1Antlr4Listener) ExitView_name(ctx *View_nameContext) {} - -// EnterOpt_id_prefix is called when production opt_id_prefix is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOpt_id_prefix(ctx *Opt_id_prefixContext) {} - -// ExitOpt_id_prefix is called when production opt_id_prefix is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOpt_id_prefix(ctx *Opt_id_prefixContext) {} - -// EnterCluster_expr is called when production cluster_expr is entered. -func (s *BaseYQLv1Antlr4Listener) EnterCluster_expr(ctx *Cluster_exprContext) {} - -// ExitCluster_expr is called when production cluster_expr is exited. -func (s *BaseYQLv1Antlr4Listener) ExitCluster_expr(ctx *Cluster_exprContext) {} - -// EnterId_or_type is called when production id_or_type is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_or_type(ctx *Id_or_typeContext) {} - -// ExitId_or_type is called when production id_or_type is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_or_type(ctx *Id_or_typeContext) {} - -// EnterOpt_id_prefix_or_type is called when production opt_id_prefix_or_type is entered. -func (s *BaseYQLv1Antlr4Listener) EnterOpt_id_prefix_or_type(ctx *Opt_id_prefix_or_typeContext) {} - -// ExitOpt_id_prefix_or_type is called when production opt_id_prefix_or_type is exited. -func (s *BaseYQLv1Antlr4Listener) ExitOpt_id_prefix_or_type(ctx *Opt_id_prefix_or_typeContext) {} - -// EnterId_or_at is called when production id_or_at is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_or_at(ctx *Id_or_atContext) {} - -// ExitId_or_at is called when production id_or_at is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_or_at(ctx *Id_or_atContext) {} - -// EnterId_table_or_type is called when production id_table_or_type is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_table_or_type(ctx *Id_table_or_typeContext) {} - -// ExitId_table_or_type is called when production id_table_or_type is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_table_or_type(ctx *Id_table_or_typeContext) {} - -// EnterId_table_or_at is called when production id_table_or_at is entered. -func (s *BaseYQLv1Antlr4Listener) EnterId_table_or_at(ctx *Id_table_or_atContext) {} - -// ExitId_table_or_at is called when production id_table_or_at is exited. -func (s *BaseYQLv1Antlr4Listener) ExitId_table_or_at(ctx *Id_table_or_atContext) {} - -// EnterKeyword is called when production keyword is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword(ctx *KeywordContext) {} - -// ExitKeyword is called when production keyword is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword(ctx *KeywordContext) {} - -// EnterKeyword_expr_uncompat is called when production keyword_expr_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_expr_uncompat(ctx *Keyword_expr_uncompatContext) {} - -// ExitKeyword_expr_uncompat is called when production keyword_expr_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_expr_uncompat(ctx *Keyword_expr_uncompatContext) {} - -// EnterKeyword_table_uncompat is called when production keyword_table_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_table_uncompat(ctx *Keyword_table_uncompatContext) {} - -// ExitKeyword_table_uncompat is called when production keyword_table_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_table_uncompat(ctx *Keyword_table_uncompatContext) {} - -// EnterKeyword_select_uncompat is called when production keyword_select_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_select_uncompat(ctx *Keyword_select_uncompatContext) {} - -// ExitKeyword_select_uncompat is called when production keyword_select_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_select_uncompat(ctx *Keyword_select_uncompatContext) {} - -// EnterKeyword_alter_uncompat is called when production keyword_alter_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_alter_uncompat(ctx *Keyword_alter_uncompatContext) {} - -// ExitKeyword_alter_uncompat is called when production keyword_alter_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_alter_uncompat(ctx *Keyword_alter_uncompatContext) {} - -// EnterKeyword_in_uncompat is called when production keyword_in_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_in_uncompat(ctx *Keyword_in_uncompatContext) {} - -// ExitKeyword_in_uncompat is called when production keyword_in_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_in_uncompat(ctx *Keyword_in_uncompatContext) {} - -// EnterKeyword_window_uncompat is called when production keyword_window_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_window_uncompat(ctx *Keyword_window_uncompatContext) {} - -// ExitKeyword_window_uncompat is called when production keyword_window_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_window_uncompat(ctx *Keyword_window_uncompatContext) {} - -// EnterKeyword_hint_uncompat is called when production keyword_hint_uncompat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_hint_uncompat(ctx *Keyword_hint_uncompatContext) {} - -// ExitKeyword_hint_uncompat is called when production keyword_hint_uncompat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_hint_uncompat(ctx *Keyword_hint_uncompatContext) {} - -// EnterKeyword_as_compat is called when production keyword_as_compat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_as_compat(ctx *Keyword_as_compatContext) {} - -// ExitKeyword_as_compat is called when production keyword_as_compat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_as_compat(ctx *Keyword_as_compatContext) {} - -// EnterKeyword_compat is called when production keyword_compat is entered. -func (s *BaseYQLv1Antlr4Listener) EnterKeyword_compat(ctx *Keyword_compatContext) {} - -// ExitKeyword_compat is called when production keyword_compat is exited. -func (s *BaseYQLv1Antlr4Listener) ExitKeyword_compat(ctx *Keyword_compatContext) {} - -// EnterType_id is called when production type_id is entered. -func (s *BaseYQLv1Antlr4Listener) EnterType_id(ctx *Type_idContext) {} - -// ExitType_id is called when production type_id is exited. -func (s *BaseYQLv1Antlr4Listener) ExitType_id(ctx *Type_idContext) {} - -// EnterBool_value is called when production bool_value is entered. -func (s *BaseYQLv1Antlr4Listener) EnterBool_value(ctx *Bool_valueContext) {} - -// ExitBool_value is called when production bool_value is exited. -func (s *BaseYQLv1Antlr4Listener) ExitBool_value(ctx *Bool_valueContext) {} - -// EnterReal is called when production real is entered. -func (s *BaseYQLv1Antlr4Listener) EnterReal(ctx *RealContext) {} - -// ExitReal is called when production real is exited. -func (s *BaseYQLv1Antlr4Listener) ExitReal(ctx *RealContext) {} - -// EnterInteger is called when production integer is entered. -func (s *BaseYQLv1Antlr4Listener) EnterInteger(ctx *IntegerContext) {} - -// ExitInteger is called when production integer is exited. -func (s *BaseYQLv1Antlr4Listener) ExitInteger(ctx *IntegerContext) {}